TBR v23: Add FromZero method to Target to efficiently fill in zero value
MultiPart: 1/6
Change-Id: I32016dc8ca3cdde6c8b563b51bb5e8258ee858e5
diff --git a/discovery/.api b/discovery/.api
index 5d4e1e0..44bb2a7 100644
--- a/discovery/.api
+++ b/discovery/.api
@@ -3,10 +3,12 @@
pkg discovery, method (*AdId) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg discovery, method (*AdId) MakeVDLTarget() vdl.Target
pkg discovery, method (*AdIdTarget) FromBytes([]byte, *vdl.Type) error
+pkg discovery, method (*AdIdTarget) FromZero(*vdl.Type) error
pkg discovery, method (*Advertisement) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg discovery, method (*Advertisement) MakeVDLTarget() vdl.Target
pkg discovery, method (*AdvertisementTarget) FinishField(vdl.Target, vdl.Target) error
pkg discovery, method (*AdvertisementTarget) FinishFields(vdl.FieldsTarget) error
+pkg discovery, method (*AdvertisementTarget) FromZero(*vdl.Type) error
pkg discovery, method (*AdvertisementTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg discovery, method (*AdvertisementTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg discovery, method (*Attachments) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -14,6 +16,7 @@
pkg discovery, method (*AttachmentsTarget) FinishField(vdl.Target, vdl.Target) error
pkg discovery, method (*AttachmentsTarget) FinishKeyStartField(vdl.Target) (vdl.Target, error)
pkg discovery, method (*AttachmentsTarget) FinishMap(vdl.MapTarget) error
+pkg discovery, method (*AttachmentsTarget) FromZero(*vdl.Type) error
pkg discovery, method (*AttachmentsTarget) StartKey() (vdl.Target, error)
pkg discovery, method (*AttachmentsTarget) StartMap(*vdl.Type, int) (vdl.MapTarget, error)
pkg discovery, method (*Attributes) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -21,6 +24,7 @@
pkg discovery, method (*AttributesTarget) FinishField(vdl.Target, vdl.Target) error
pkg discovery, method (*AttributesTarget) FinishKeyStartField(vdl.Target) (vdl.Target, error)
pkg discovery, method (*AttributesTarget) FinishMap(vdl.MapTarget) error
+pkg discovery, method (*AttributesTarget) FromZero(*vdl.Type) error
pkg discovery, method (*AttributesTarget) StartKey() (vdl.Target, error)
pkg discovery, method (*AttributesTarget) StartMap(*vdl.Type, int) (vdl.MapTarget, error)
pkg discovery, method (AdId) IsValid() bool
diff --git a/discovery/discovery.vdl.go b/discovery/discovery.vdl.go
index 23dbf4c..f01f6f5 100644
--- a/discovery/discovery.vdl.go
+++ b/discovery/discovery.vdl.go
@@ -50,6 +50,10 @@
return nil
}
+func (t *AdIdTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = AdId{}
+ return nil
+}
// Attributes represents service attributes as a key/value pair.
type Attributes map[string]string
@@ -134,6 +138,10 @@
return nil
}
+func (t *AttributesTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Attributes(nil)
+ return nil
+}
// Attachments represents service attachments as a key/value pair.
type Attachments map[string][]byte
@@ -219,6 +227,10 @@
return nil
}
+func (t *AttachmentsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Attachments(nil)
+ return nil
+}
// Advertisement represents a feed into advertiser to broadcast its contents
// to scanners.
@@ -263,84 +275,132 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Id")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Id.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Id == AdId{})
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Id.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("InterfaceName")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.InterfaceName), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Addresses")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("InterfaceName")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget8, err := fieldTarget7.StartList(tt.NonOptional().Field(2).Type, len(m.Addresses))
- if err != nil {
+ var7 := (m.InterfaceName == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.InterfaceName), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
- for i, elem10 := range m.Addresses {
- elemTarget9, err := listTarget8.StartElem(i)
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Addresses")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var10 bool
+ if len(m.Addresses) == 0 {
+ var10 = true
+ }
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget11, err := fieldTarget9.StartList(tt.NonOptional().Field(2).Type, len(m.Addresses))
if err != nil {
return err
}
- if err := elemTarget9.FromString(string(elem10), tt.NonOptional().Field(2).Type.Elem()); err != nil {
- return err
+ for i, elem13 := range m.Addresses {
+ elemTarget12, err := listTarget11.StartElem(i)
+ if err != nil {
+ return err
+ }
+ if err := elemTarget12.FromString(string(elem13), tt.NonOptional().Field(2).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget11.FinishElem(elemTarget12); err != nil {
+ return err
+ }
}
- if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ if err := fieldTarget9.FinishList(listTarget11); err != nil {
return err
}
}
- if err := fieldTarget7.FinishList(listTarget8); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Attributes")
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Attributes")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Attributes.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
- return err
+ var var16 bool
+ if len(m.Attributes) == 0 {
+ var16 = true
}
- if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Attributes.FillVDLTarget(fieldTarget15, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
- keyTarget13, fieldTarget14, err := fieldsTarget1.StartField("Attachments")
+ keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("Attachments")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Attachments.FillVDLTarget(fieldTarget14, tt.NonOptional().Field(4).Type); err != nil {
- return err
+ var var19 bool
+ if len(m.Attachments) == 0 {
+ var19 = true
}
- if err := fieldsTarget1.FinishField(keyTarget13, fieldTarget14); err != nil {
+ if var19 {
+ if err := fieldTarget18.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Attachments.FillVDLTarget(fieldTarget18, tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
return err
}
}
@@ -405,14 +465,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroAdId = AdId{}
- __VDLZeroAttributes = Attributes(nil)
- __VDLZeroAttachments = Attachments(nil)
- __VDLZeroAdvertisement = Advertisement{}
-)
+func (t *AdvertisementTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Advertisement{}
+ return nil
+}
var __VDLInitCalled bool
@@ -433,6 +489,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*AdId)(nil))
diff --git a/flow/.api b/flow/.api
index 3537c45..b616cc1 100644
--- a/flow/.api
+++ b/flow/.api
@@ -80,12 +80,12 @@
pkg flow, type Protocol interface, Dial(*context.T, string, string, time.Duration) (Conn, error)
pkg flow, type Protocol interface, Listen(*context.T, string, string) (Listener, error)
pkg flow, type Protocol interface, Resolve(*context.T, string, string) (string, []string, error)
-pkg flow, var ErrAborted verror.IDAction
-pkg flow, var ErrAuth verror.IDAction
-pkg flow, var ErrBadArg verror.IDAction
-pkg flow, var ErrBadState verror.IDAction
-pkg flow, var ErrDialFailed verror.IDAction
-pkg flow, var ErrNetwork verror.IDAction
-pkg flow, var ErrNotTrusted verror.IDAction
-pkg flow, var ErrProxy verror.IDAction
-pkg flow, var ErrResolveFailed verror.IDAction
+pkg flow, var ErrAborted unknown-type
+pkg flow, var ErrAuth unknown-type
+pkg flow, var ErrBadArg unknown-type
+pkg flow, var ErrBadState unknown-type
+pkg flow, var ErrDialFailed unknown-type
+pkg flow, var ErrNetwork unknown-type
+pkg flow, var ErrNotTrusted unknown-type
+pkg flow, var ErrProxy unknown-type
+pkg flow, var ErrResolveFailed unknown-type
diff --git a/flow/flow.vdl.go b/flow/flow.vdl.go
index 3036fcd..0fd90b7 100644
--- a/flow/flow.vdl.go
+++ b/flow/flow.vdl.go
@@ -93,6 +93,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Set error format strings.
i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrAuth.ID), "{1:}{2:} {:3}")
diff --git a/flow/message/.api b/flow/message/.api
index 8af5b06..fe361d7 100644
--- a/flow/message/.api
+++ b/flow/message/.api
@@ -50,7 +50,7 @@
pkg message, type Setup struct, Versions version.RPCVersionRange
pkg message, type TearDown struct
pkg message, type TearDown struct, Message string
-pkg message, var ErrInvalidMsg verror.IDAction
-pkg message, var ErrInvalidSetupOption verror.IDAction
-pkg message, var ErrMissingBlessings verror.IDAction
-pkg message, var ErrUnknownMsg verror.IDAction
+pkg message, var ErrInvalidMsg unknown-type
+pkg message, var ErrInvalidSetupOption unknown-type
+pkg message, var ErrMissingBlessings unknown-type
+pkg message, var ErrUnknownMsg unknown-type
diff --git a/flow/message/message.vdl.go b/flow/message/message.vdl.go
index 6426217..459b73b 100644
--- a/flow/message/message.vdl.go
+++ b/flow/message/message.vdl.go
@@ -63,6 +63,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Set error format strings.
i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrInvalidMsg.ID), "{1:}{2:} message of type {3} and size {4} failed decoding at field {5}{:6}.")
diff --git a/naming/.api b/naming/.api
index 46e8919..3aab0ad 100644
--- a/naming/.api
+++ b/naming/.api
@@ -22,16 +22,19 @@
pkg naming, func Unescape(string) (string, bool)
pkg naming, method (*GlobChildrenReplyTarget) FinishField(vdl.Target, vdl.Target) error
pkg naming, method (*GlobChildrenReplyTarget) FinishFields(vdl.FieldsTarget) error
+pkg naming, method (*GlobChildrenReplyTarget) FromZero(*vdl.Type) error
pkg naming, method (*GlobChildrenReplyTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg naming, method (*GlobChildrenReplyTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg naming, method (*GlobError) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg naming, method (*GlobError) MakeVDLTarget() vdl.Target
pkg naming, method (*GlobErrorTarget) FinishField(vdl.Target, vdl.Target) error
pkg naming, method (*GlobErrorTarget) FinishFields(vdl.FieldsTarget) error
+pkg naming, method (*GlobErrorTarget) FromZero(*vdl.Type) error
pkg naming, method (*GlobErrorTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg naming, method (*GlobErrorTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg naming, method (*GlobReplyTarget) FinishField(vdl.Target, vdl.Target) error
pkg naming, method (*GlobReplyTarget) FinishFields(vdl.FieldsTarget) error
+pkg naming, method (*GlobReplyTarget) FromZero(*vdl.Type) error
pkg naming, method (*GlobReplyTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg naming, method (*GlobReplyTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg naming, method (*MountEntry) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -39,6 +42,7 @@
pkg naming, method (*MountEntry) Names() []string
pkg naming, method (*MountEntryTarget) FinishField(vdl.Target, vdl.Target) error
pkg naming, method (*MountEntryTarget) FinishFields(vdl.FieldsTarget) error
+pkg naming, method (*MountEntryTarget) FromZero(*vdl.Type) error
pkg naming, method (*MountEntryTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg naming, method (*MountEntryTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg naming, method (*MountFlag) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -46,10 +50,12 @@
pkg naming, method (*MountFlagTarget) FromFloat(float64, *vdl.Type) error
pkg naming, method (*MountFlagTarget) FromInt(int64, *vdl.Type) error
pkg naming, method (*MountFlagTarget) FromUint(uint64, *vdl.Type) error
+pkg naming, method (*MountFlagTarget) FromZero(*vdl.Type) error
pkg naming, method (*MountedServer) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg naming, method (*MountedServer) MakeVDLTarget() vdl.Target
pkg naming, method (*MountedServerTarget) FinishField(vdl.Target, vdl.Target) error
pkg naming, method (*MountedServerTarget) FinishFields(vdl.FieldsTarget) error
+pkg naming, method (*MountedServerTarget) FromZero(*vdl.Type) error
pkg naming, method (*MountedServerTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg naming, method (*MountedServerTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg naming, method (*RoutingID) FromString(string) error
diff --git a/naming/naming.vdl.go b/naming/naming.vdl.go
index 3ea123e..95687f8 100644
--- a/naming/naming.vdl.go
+++ b/naming/naming.vdl.go
@@ -74,6 +74,10 @@
return nil
}
+func (t *MountFlagTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MountFlag(0)
+ return nil
+}
// MountedServer represents a server mounted on a specific name.
type MountedServer struct {
@@ -93,34 +97,49 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Server")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Server), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Server == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Server), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- var wireValue4 time.WireDeadline
- if err := time.WireDeadlineFromNative(&wireValue4, m.Deadline); err != nil {
+ var wireValue5 time.WireDeadline
+ if err := time.WireDeadlineFromNative(&wireValue5, m.Deadline); err != nil {
return err
}
- keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Deadline")
+ keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Deadline")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue4.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var8 := (wireValue5 == time.WireDeadline{})
+ if var8 {
+ if err := fieldTarget7.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue5.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
return err
}
}
@@ -170,6 +189,10 @@
return nil
}
+func (t *MountedServerTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MountedServer{}
+ return nil
+}
// MountEntry represents a given name mounted in the mounttable.
type MountEntry struct {
@@ -193,73 +216,107 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Servers")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Servers")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget6, err := fieldTarget5.StartList(tt.NonOptional().Field(1).Type, len(m.Servers))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.Servers) == 0 {
+ var7 = true
}
- for i, elem8 := range m.Servers {
- elemTarget7, err := listTarget6.StartElem(i)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.Servers))
if err != nil {
return err
}
+ for i, elem10 := range m.Servers {
+ elemTarget9, err := listTarget8.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem8.FillVDLTarget(elemTarget7, tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ return err
+ }
}
- if err := listTarget6.FinishElem(elemTarget7); err != nil {
+ if err := fieldTarget6.FinishList(listTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishList(listTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("ServesMountTable")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("ServesMountTable")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget10.FromBool(bool(m.ServesMountTable), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
- return err
- }
- }
- keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("IsLeaf")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget12.FromBool(bool(m.IsLeaf), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var13 := (m.ServesMountTable == false)
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget12.FromBool(bool(m.ServesMountTable), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("IsLeaf")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var16 := (m.IsLeaf == false)
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget15.FromBool(bool(m.IsLeaf), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -316,6 +373,10 @@
return nil
}
+func (t *MountEntryTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MountEntry{}
+ return nil
+}
// []MountedServer
type __VDLTarget1_list struct {
@@ -349,6 +410,10 @@
return nil
}
+func (t *__VDLTarget1_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []MountedServer(nil)
+ return nil
+}
// GlobError is returned by namespace.Glob to indicate a subtree of the namespace
// that could not be traversed.
@@ -369,40 +434,49 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Error")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Error")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.Error == nil {
- if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
+ var7 := (m.Error == (error)(nil))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- var wireError6 vdl.WireError
- if err := verror.WireFromNative(&wireError6, m.Error); err != nil {
+
+ var wireError8 vdl.WireError
+ if err := verror.WireFromNative(&wireError8, m.Error); err != nil {
return err
}
- if err := wireError6.FillVDLTarget(fieldTarget5, vdl.ErrorType); err != nil {
+ if err := wireError8.FillVDLTarget(fieldTarget6, vdl.ErrorType); err != nil {
return err
}
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -452,6 +526,10 @@
return nil
}
+func (t *GlobErrorTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = GlobError{}
+ return nil
+}
type (
// GlobReply represents any single field of the GlobReply union type.
@@ -589,6 +667,10 @@
return nil
}
+func (t *GlobReplyTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = GlobReply(GlobReplyEntry{})
+ return nil
+}
type globReplyTargetFactory struct{}
@@ -734,6 +816,10 @@
return nil
}
+func (t *GlobChildrenReplyTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = GlobChildrenReply(GlobChildrenReplyName{})
+ return nil
+}
type globChildrenReplyTargetFactory struct{}
@@ -744,16 +830,6 @@
return nil, fmt.Errorf("got %T, want *GlobChildrenReply", union)
}
-// Create zero values for each type.
-var (
- __VDLZeroMountFlag = MountFlag(0)
- __VDLZeroMountedServer = MountedServer{}
- __VDLZeroMountEntry = MountEntry{}
- __VDLZeroGlobError = GlobError{}
- __VDLZeroGlobReply = GlobReply(GlobReplyEntry{})
- __VDLZeroGlobChildrenReply = GlobChildrenReply(GlobChildrenReplyName{})
-)
-
//////////////////////////////////////////////////
// Const definitions
@@ -780,6 +856,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*MountFlag)(nil))
diff --git a/query/engine/internal/testdata/testdata.vdl.go b/query/engine/internal/testdata/testdata.vdl.go
index d52fde0..c1fe3cf 100644
--- a/query/engine/internal/testdata/testdata.vdl.go
+++ b/query/engine/internal/testdata/testdata.vdl.go
@@ -37,55 +37,86 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Street")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Street), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Street == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Street), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("City")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("City")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.City), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.City == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.City), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("State")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("State")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromString(string(m.State), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Zip")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget9.FromString(string(m.Zip), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var10 := (m.State == "")
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromString(string(m.State), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Zip")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var13 := (m.Zip == "")
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget12.FromString(string(m.Zip), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -142,6 +173,10 @@
return nil
}
+func (t *AddressInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = AddressInfo{}
+ return nil
+}
type CreditAgency int
@@ -225,11 +260,15 @@
case "TransUnion":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum v.io/v23/query/engine/internal/testdata.CreditAgency", src)
+ return fmt.Errorf("label %s not in enum CreditAgency", src)
}
return nil
}
+func (t *CreditAgencyTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = CreditAgencyEquifax
+ return nil
+}
type ExperianRating int
@@ -305,11 +344,15 @@
case "Bad":
*t.Value = 1
default:
- return fmt.Errorf("label %s not in enum v.io/v23/query/engine/internal/testdata.ExperianRating", src)
+ return fmt.Errorf("label %s not in enum ExperianRating", src)
}
return nil
}
+func (t *ExperianRatingTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ExperianRatingGood
+ return nil
+}
type RatingsArray [4]int16
@@ -372,6 +415,10 @@
return nil
}
+func (t *RatingsArrayTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = RatingsArray{}
+ return nil
+}
type EquifaxCreditReport struct {
Rating byte
@@ -388,29 +435,44 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromUint(uint64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Rating == byte(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromUint(uint64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("FourScoreRatings")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("FourScoreRatings")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.FourScoreRatings.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.FourScoreRatings == RatingsArray{})
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.FourScoreRatings.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -460,6 +522,10 @@
return nil
}
+func (t *EquifaxCreditReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = EquifaxCreditReport{}
+ return nil
+}
type Tdh int
@@ -543,11 +609,15 @@
case "Harry":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum v.io/v23/query/engine/internal/testdata.Tdh", src)
+ return fmt.Errorf("label %s not in enum Tdh", src)
}
return nil
}
+func (t *TdhTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = TdhTom
+ return nil
+}
type ExperianCreditReport struct {
Rating ExperianRating
@@ -565,60 +635,86 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Rating.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Rating == ExperianRatingGood)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Rating.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("TdhApprovals")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("TdhApprovals")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget6, err := fieldTarget5.StartSet(tt.NonOptional().Field(1).Type, len(m.TdhApprovals))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.TdhApprovals) == 0 {
+ var7 = true
}
- for key8 := range m.TdhApprovals {
- keyTarget7, err := setTarget6.StartKey()
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget8, err := fieldTarget6.StartSet(tt.NonOptional().Field(1).Type, len(m.TdhApprovals))
if err != nil {
return err
}
+ for key10 := range m.TdhApprovals {
+ keyTarget9, err := setTarget8.StartKey()
+ if err != nil {
+ return err
+ }
- if err := key8.FillVDLTarget(keyTarget7, tt.NonOptional().Field(1).Type.Key()); err != nil {
- return err
+ if err := key10.FillVDLTarget(keyTarget9, tt.NonOptional().Field(1).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget8.FinishKey(keyTarget9); err != nil {
+ return err
+ }
}
- if err := setTarget6.FinishKey(keyTarget7); err != nil {
+ if err := fieldTarget6.FinishSet(setTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishSet(setTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Auditor")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Auditor")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Auditor.FillVDLTarget(fieldTarget10, tt.NonOptional().Field(2).Type); err != nil {
- return err
+ var13 := (m.Auditor == TdhTom)
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Auditor.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
@@ -673,6 +769,10 @@
return nil
}
+func (t *ExperianCreditReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ExperianCreditReport{}
+ return nil
+}
// map[Tdh]struct{}
type __VDLTarget1_set struct {
@@ -708,6 +808,10 @@
return nil
}
+func (t *__VDLTarget1_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[Tdh]struct{}(nil)
+ return nil
+}
type TransUnionCreditReport struct {
Rating int16
@@ -724,52 +828,70 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromInt(int64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Rating == int16(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromInt(int64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("PreviousRatings")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("PreviousRatings")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget6, err := fieldTarget5.StartMap(tt.NonOptional().Field(1).Type, len(m.PreviousRatings))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.PreviousRatings) == 0 {
+ var7 = true
}
- for key8, value10 := range m.PreviousRatings {
- keyTarget7, err := mapTarget6.StartKey()
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget8, err := fieldTarget6.StartMap(tt.NonOptional().Field(1).Type, len(m.PreviousRatings))
if err != nil {
return err
}
- if err := keyTarget7.FromString(string(key8), tt.NonOptional().Field(1).Type.Key()); err != nil {
- return err
+ for key10, value12 := range m.PreviousRatings {
+ keyTarget9, err := mapTarget8.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget9.FromString(string(key10), tt.NonOptional().Field(1).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget11, err := mapTarget8.FinishKeyStartField(keyTarget9)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget11.FromInt(int64(value12), tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget8.FinishField(keyTarget9, valueTarget11); err != nil {
+ return err
+ }
}
- valueTarget9, err := mapTarget6.FinishKeyStartField(keyTarget7)
- if err != nil {
- return err
- }
- if err := valueTarget9.FromInt(int64(value10), tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget6.FinishField(keyTarget7, valueTarget9); err != nil {
+ if err := fieldTarget6.FinishMap(mapTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishMap(mapTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -819,6 +941,10 @@
return nil
}
+func (t *TransUnionCreditReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = TransUnionCreditReport{}
+ return nil
+}
// map[string]int16
type __VDLTarget2_map struct {
@@ -862,6 +988,10 @@
return nil
}
+func (t *__VDLTarget2_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[string]int16(nil)
+ return nil
+}
type (
// AgencyReport represents any single field of the AgencyReport union type.
@@ -1037,6 +1167,10 @@
return nil
}
+func (t *AgencyReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = AgencyReport(AgencyReportEquifaxReport{})
+ return nil
+}
type agencyReportTargetFactory struct{}
@@ -1062,34 +1196,54 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Agency")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Agency.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Agency == CreditAgencyEquifax)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Agency.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Report")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Report")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- unionValue6 := m.Report
- if unionValue6 == nil {
- unionValue6 = AgencyReportEquifaxReport{}
+ var var7 bool
+ if field, ok := m.Report.(AgencyReportEquifaxReport); ok {
+
+ var8 := (field.Value == EquifaxCreditReport{})
+ var7 = var8
}
- if err := unionValue6.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ unionValue9 := m.Report
+ if unionValue9 == nil {
+ unionValue9 = AgencyReportEquifaxReport{}
+ }
+ if err := unionValue9.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1139,6 +1293,12 @@
return nil
}
+func (t *CreditReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = CreditReport{
+ Report: AgencyReportEquifaxReport{},
+ }
+ return nil
+}
type Customer struct {
Name string
@@ -1159,96 +1319,155 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Id")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromInt(int64(m.Id), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Active")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromBool(bool(m.Active), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Address")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Id")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Address.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
+ var7 := (m.Id == int64(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromInt(int64(m.Id), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Active")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var10 := (m.Active == false)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromBool(bool(m.Active), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("PreviousAddresses")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Address")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget12, err := fieldTarget11.StartList(tt.NonOptional().Field(4).Type, len(m.PreviousAddresses))
- if err != nil {
+ var13 := (m.Address == AddressInfo{})
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Address.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
- for i, elem14 := range m.PreviousAddresses {
- elemTarget13, err := listTarget12.StartElem(i)
+ }
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("PreviousAddresses")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var16 bool
+ if len(m.PreviousAddresses) == 0 {
+ var16 = true
+ }
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget17, err := fieldTarget15.StartList(tt.NonOptional().Field(4).Type, len(m.PreviousAddresses))
if err != nil {
return err
}
+ for i, elem19 := range m.PreviousAddresses {
+ elemTarget18, err := listTarget17.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem14.FillVDLTarget(elemTarget13, tt.NonOptional().Field(4).Type.Elem()); err != nil {
- return err
+ if err := elem19.FillVDLTarget(elemTarget18, tt.NonOptional().Field(4).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget17.FinishElem(elemTarget18); err != nil {
+ return err
+ }
}
- if err := listTarget12.FinishElem(elemTarget13); err != nil {
+ if err := fieldTarget15.FinishList(listTarget17); err != nil {
return err
}
}
- if err := fieldTarget11.FinishList(listTarget12); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
- keyTarget15, fieldTarget16, err := fieldsTarget1.StartField("Credit")
+ keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("Credit")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Credit.FillVDLTarget(fieldTarget16, tt.NonOptional().Field(5).Type); err != nil {
- return err
+ var22 := true
+ var23 := (m.Credit.Agency == CreditAgencyEquifax)
+ var22 = var22 && var23
+ var var24 bool
+ if field, ok := m.Credit.Report.(AgencyReportEquifaxReport); ok {
+
+ var25 := (field.Value == EquifaxCreditReport{})
+ var24 = var25
}
- if err := fieldsTarget1.FinishField(keyTarget15, fieldTarget16); err != nil {
+ var22 = var22 && var24
+ if var22 {
+ if err := fieldTarget21.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Credit.FillVDLTarget(fieldTarget21, tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
return err
}
}
@@ -1318,6 +1537,14 @@
return nil
}
+func (t *CustomerTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Customer{
+ Credit: CreditReport{
+ Report: AgencyReportEquifaxReport{},
+ },
+ }
+ return nil
+}
// []AddressInfo
type __VDLTarget3_list struct {
@@ -1351,6 +1578,10 @@
return nil
}
+func (t *__VDLTarget3_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []AddressInfo(nil)
+ return nil
+}
type Invoice struct {
CustId int64
@@ -1370,71 +1601,110 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("CustId")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromInt(int64(m.CustId), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.CustId == int64(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromInt(int64(m.CustId), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("InvoiceNum")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromInt(int64(m.InvoiceNum), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- var wireValue6 time_2.Time
- if err := time_2.TimeFromNative(&wireValue6, m.InvoiceDate); err != nil {
- return err
- }
-
- keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("InvoiceDate")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("InvoiceNum")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue6.FillVDLTarget(fieldTarget8, tt.NonOptional().Field(2).Type); err != nil {
- return err
+ var7 := (m.InvoiceNum == int64(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromInt(int64(m.InvoiceNum), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Amount")
+ var wireValue8 time_2.Time
+ if err := time_2.TimeFromNative(&wireValue8, m.InvoiceDate); err != nil {
+ return err
+ }
+
+ keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("InvoiceDate")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget10.FromInt(int64(m.Amount), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var11 := (wireValue8 == time_2.Time{})
+ if var11 {
+ if err := fieldTarget10.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue8.FillVDLTarget(fieldTarget10, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
return err
}
}
- keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("ShipTo")
+ keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("Amount")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.ShipTo.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(4).Type); err != nil {
+ var14 := (m.Amount == int64(0))
+ if var14 {
+ if err := fieldTarget13.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget13.FromInt(int64(m.Amount), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ }
+ keyTarget15, fieldTarget16, err := fieldsTarget1.StartField("ShipTo")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var17 := (m.ShipTo == AddressInfo{})
+ if var17 {
+ if err := fieldTarget16.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.ShipTo.FillVDLTarget(fieldTarget16, tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget15, fieldTarget16); err != nil {
return err
}
}
@@ -1499,6 +1769,10 @@
return nil
}
+func (t *InvoiceTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Invoice{}
+ return nil
+}
type Numbers struct {
B byte
@@ -1522,112 +1796,183 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromUint(uint64(m.B), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.B == byte(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromUint(uint64(m.B), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Ui16")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Ui16")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromUint(uint64(m.Ui16), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Ui16 == uint16(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromUint(uint64(m.Ui16), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Ui32")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Ui32")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromUint(uint64(m.Ui32), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Ui64")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget9.FromUint(uint64(m.Ui64), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var10 := (m.Ui32 == uint32(0))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromUint(uint64(m.Ui32), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("I16")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Ui64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget11.FromInt(int64(m.I16), tt.NonOptional().Field(4).Type); err != nil {
- return err
+
+ var13 := (m.Ui64 == uint64(0))
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget12.FromUint(uint64(m.Ui64), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
- keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("I32")
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("I16")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget13.FromInt(int64(m.I32), tt.NonOptional().Field(5).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
- return err
- }
- }
- keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("I64")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget15.FromInt(int64(m.I64), tt.NonOptional().Field(6).Type); err != nil {
- return err
+
+ var16 := (m.I16 == int16(0))
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget15.FromInt(int64(m.I16), tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
- keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("F32")
+ keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("I32")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget17.FromFloat(float64(m.F32), tt.NonOptional().Field(7).Type); err != nil {
- return err
+
+ var19 := (m.I32 == int32(0))
+ if var19 {
+ if err := fieldTarget18.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget18.FromInt(int64(m.I32), tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
return err
}
}
- keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("F64")
+ keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("I64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget19.FromFloat(float64(m.F64), tt.NonOptional().Field(8).Type); err != nil {
+
+ var22 := (m.I64 == int64(0))
+ if var22 {
+ if err := fieldTarget21.FromZero(tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget21.FromInt(int64(m.I64), tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil {
+ }
+ keyTarget23, fieldTarget24, err := fieldsTarget1.StartField("F32")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var25 := (m.F32 == float32(0))
+ if var25 {
+ if err := fieldTarget24.FromZero(tt.NonOptional().Field(7).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget24.FromFloat(float64(m.F32), tt.NonOptional().Field(7).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget23, fieldTarget24); err != nil {
+ return err
+ }
+ }
+ keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("F64")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var28 := (m.F64 == float64(0))
+ if var28 {
+ if err := fieldTarget27.FromZero(tt.NonOptional().Field(8).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget27.FromFloat(float64(m.F64), tt.NonOptional().Field(8).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
return err
}
}
@@ -1712,6 +2057,10 @@
return nil
}
+func (t *NumbersTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Numbers{}
+ return nil
+}
type (
// TitleOrValueType represents any single field of the TitleOrValueType union type.
@@ -1845,6 +2194,10 @@
return nil
}
+func (t *TitleOrValueTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = TitleOrValueType(TitleOrValueTypeTitle{})
+ return nil
+}
type titleOrValueTypeTargetFactory struct{}
@@ -1870,33 +2223,53 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("TitleOrValue")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("TitleOrValue")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- unionValue6 := m.TitleOrValue
- if unionValue6 == nil {
- unionValue6 = TitleOrValueTypeTitle{}
+ var var7 bool
+ if field, ok := m.TitleOrValue.(TitleOrValueTypeTitle); ok {
+
+ var8 := (field.Value == "")
+ var7 = var8
}
- if err := unionValue6.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ unionValue9 := m.TitleOrValue
+ if unionValue9 == nil {
+ unionValue9 = TitleOrValueTypeTitle{}
+ }
+ if err := unionValue9.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1946,6 +2319,12 @@
return nil
}
+func (t *BazTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BazType{
+ TitleOrValue: TitleOrValueTypeTitle{},
+ }
+ return nil
+}
type BarType struct {
Baz BazType
@@ -1961,15 +2340,24 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Baz")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Baz.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Baz == BazType{
+ TitleOrValue: TitleOrValueTypeTitle{},
+ })
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Baz.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -2016,6 +2404,14 @@
return nil
}
+func (t *BarTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BarType{
+ Baz: BazType{
+ TitleOrValue: TitleOrValueTypeTitle{},
+ },
+ }
+ return nil
+}
type FooType struct {
Bar BarType
@@ -2031,15 +2427,26 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Bar")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Bar.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Bar == BarType{
+ Baz: BazType{
+ TitleOrValue: TitleOrValueTypeTitle{},
+ },
+ })
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Bar.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -2086,6 +2493,16 @@
return nil
}
+func (t *FooTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = FooType{
+ Bar: BarType{
+ Baz: BazType{
+ TitleOrValue: TitleOrValueTypeTitle{},
+ },
+ },
+ }
+ return nil
+}
type K struct {
A byte
@@ -2102,28 +2519,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromUint(uint64(m.A), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.A == byte(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromUint(uint64(m.A), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.B), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.B == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.B), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -2173,6 +2605,10 @@
return nil
}
+func (t *KTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = K{}
+ return nil
+}
type V struct {
A string
@@ -2189,28 +2625,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.A), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.A == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.A), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromFloat(float64(m.B), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.B == float32(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromFloat(float64(m.B), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -2260,6 +2711,10 @@
return nil
}
+func (t *VTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = V{}
+ return nil
+}
type FunWithMaps struct {
Key K
@@ -2277,125 +2732,154 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Key.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Key == K{})
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Key.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Map")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Map")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget6, err := fieldTarget5.StartMap(tt.NonOptional().Field(1).Type, len(m.Map))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.Map) == 0 {
+ var7 = true
}
- for key8, value10 := range m.Map {
- keyTarget7, err := mapTarget6.StartKey()
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget8, err := fieldTarget6.StartMap(tt.NonOptional().Field(1).Type, len(m.Map))
if err != nil {
return err
}
+ for key10, value12 := range m.Map {
+ keyTarget9, err := mapTarget8.StartKey()
+ if err != nil {
+ return err
+ }
- if err := key8.FillVDLTarget(keyTarget7, tt.NonOptional().Field(1).Type.Key()); err != nil {
- return err
- }
- valueTarget9, err := mapTarget6.FinishKeyStartField(keyTarget7)
- if err != nil {
- return err
- }
+ if err := key10.FillVDLTarget(keyTarget9, tt.NonOptional().Field(1).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget11, err := mapTarget8.FinishKeyStartField(keyTarget9)
+ if err != nil {
+ return err
+ }
- if err := value10.FillVDLTarget(valueTarget9, tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ if err := value12.FillVDLTarget(valueTarget11, tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget8.FinishField(keyTarget9, valueTarget11); err != nil {
+ return err
+ }
}
- if err := mapTarget6.FinishField(keyTarget7, valueTarget9); err != nil {
+ if err := fieldTarget6.FinishMap(mapTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishMap(mapTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Confusing")
+ keyTarget13, fieldTarget14, err := fieldsTarget1.StartField("Confusing")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget13, err := fieldTarget12.StartMap(tt.NonOptional().Field(2).Type, len(m.Confusing))
- if err != nil {
- return err
+ var var15 bool
+ if len(m.Confusing) == 0 {
+ var15 = true
}
- for key15, value17 := range m.Confusing {
- keyTarget14, err := mapTarget13.StartKey()
- if err != nil {
+ if var15 {
+ if err := fieldTarget14.FromZero(tt.NonOptional().Field(2).Type); err != nil {
return err
}
- if err := keyTarget14.FromInt(int64(key15), tt.NonOptional().Field(2).Type.Key()); err != nil {
- return err
- }
- valueTarget16, err := mapTarget13.FinishKeyStartField(keyTarget14)
- if err != nil {
- return err
- }
+ } else {
- listTarget18, err := valueTarget16.StartList(tt.NonOptional().Field(2).Type.Elem(), len(value17))
+ mapTarget16, err := fieldTarget14.StartMap(tt.NonOptional().Field(2).Type, len(m.Confusing))
if err != nil {
return err
}
- for i, elem20 := range value17 {
- elemTarget19, err := listTarget18.StartElem(i)
+ for key18, value20 := range m.Confusing {
+ keyTarget17, err := mapTarget16.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget17.FromInt(int64(key18), tt.NonOptional().Field(2).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget19, err := mapTarget16.FinishKeyStartField(keyTarget17)
if err != nil {
return err
}
- setTarget21, err := elemTarget19.StartSet(tt.NonOptional().Field(2).Type.Elem().Elem(), len(elem20))
+ listTarget21, err := valueTarget19.StartList(tt.NonOptional().Field(2).Type.Elem(), len(value20))
if err != nil {
return err
}
- for key23 := range elem20 {
- keyTarget22, err := setTarget21.StartKey()
+ for i, elem23 := range value20 {
+ elemTarget22, err := listTarget21.StartElem(i)
if err != nil {
return err
}
- if err := keyTarget22.FromString(string(key23), tt.NonOptional().Field(2).Type.Elem().Elem().Key()); err != nil {
+
+ setTarget24, err := elemTarget22.StartSet(tt.NonOptional().Field(2).Type.Elem().Elem(), len(elem23))
+ if err != nil {
return err
}
- if err := setTarget21.FinishKey(keyTarget22); err != nil {
+ for key26 := range elem23 {
+ keyTarget25, err := setTarget24.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget25.FromString(string(key26), tt.NonOptional().Field(2).Type.Elem().Elem().Key()); err != nil {
+ return err
+ }
+ if err := setTarget24.FinishKey(keyTarget25); err != nil {
+ return err
+ }
+ }
+ if err := elemTarget22.FinishSet(setTarget24); err != nil {
+ return err
+ }
+ if err := listTarget21.FinishElem(elemTarget22); err != nil {
return err
}
}
- if err := elemTarget19.FinishSet(setTarget21); err != nil {
+ if err := valueTarget19.FinishList(listTarget21); err != nil {
return err
}
- if err := listTarget18.FinishElem(elemTarget19); err != nil {
+ if err := mapTarget16.FinishField(keyTarget17, valueTarget19); err != nil {
return err
}
}
- if err := valueTarget16.FinishList(listTarget18); err != nil {
- return err
- }
- if err := mapTarget13.FinishField(keyTarget14, valueTarget16); err != nil {
+ if err := fieldTarget14.FinishMap(mapTarget16); err != nil {
return err
}
}
- if err := fieldTarget12.FinishMap(mapTarget13); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget13, fieldTarget14); err != nil {
return err
}
}
@@ -2450,6 +2934,10 @@
return nil
}
+func (t *FunWithMapsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = FunWithMaps{}
+ return nil
+}
// map[K]V
type __VDLTarget4_map struct {
@@ -2493,6 +2981,10 @@
return nil
}
+func (t *__VDLTarget4_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[K]V(nil)
+ return nil
+}
// map[int16][]map[string]struct{}
type __VDLTarget5_map struct {
@@ -2536,6 +3028,10 @@
return nil
}
+func (t *__VDLTarget5_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[int16][]map[string]struct{}(nil)
+ return nil
+}
// []map[string]struct{}
type __VDLTarget6_list struct {
@@ -2569,6 +3065,10 @@
return nil
}
+func (t *__VDLTarget6_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []map[string]struct{}(nil)
+ return nil
+}
// map[string]struct{}
type __VDLTarget7_set struct {
@@ -2604,6 +3104,10 @@
return nil
}
+func (t *__VDLTarget7_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[string]struct{}(nil)
+ return nil
+}
type FunWithTypes struct {
T1 *vdl.Type
@@ -2620,36 +3124,51 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("T1")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- typeObjectVal4 := m.T1
- if typeObjectVal4 == nil {
- typeObjectVal4 = vdl.AnyType
- }
- if err := fieldTarget3.FromTypeObject(typeObjectVal4); err != nil {
- return err
+
+ var4 := (m.T1 == vdl.AnyType)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ typeObjectVal5 := m.T1
+ if typeObjectVal5 == nil {
+ typeObjectVal5 = vdl.AnyType
+ }
+ if err := fieldTarget3.FromTypeObject(typeObjectVal5); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("T2")
+ keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("T2")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- typeObjectVal7 := m.T2
- if typeObjectVal7 == nil {
- typeObjectVal7 = vdl.AnyType
+
+ var8 := (m.T2 == vdl.AnyType)
+ if var8 {
+ if err := fieldTarget7.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ typeObjectVal9 := m.T2
+ if typeObjectVal9 == nil {
+ typeObjectVal9 = vdl.AnyType
+ }
+ if err := fieldTarget7.FromTypeObject(typeObjectVal9); err != nil {
+ return err
+ }
}
- if err := fieldTarget6.FromTypeObject(typeObjectVal7); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
return err
}
}
@@ -2699,6 +3218,13 @@
return nil
}
+func (t *FunWithTypesTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = FunWithTypes{
+ T1: vdl.AnyType,
+ T2: vdl.AnyType,
+ }
+ return nil
+}
type ManyMaps struct {
B map[bool]string
@@ -2726,502 +3252,644 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget4, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.B))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.B) == 0 {
+ var4 = true
}
- for key6, value8 := range m.B {
- keyTarget5, err := mapTarget4.StartKey()
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget5, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.B))
if err != nil {
return err
}
- if err := keyTarget5.FromBool(bool(key6), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ for key7, value9 := range m.B {
+ keyTarget6, err := mapTarget5.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget6.FromBool(bool(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget8, err := mapTarget5.FinishKeyStartField(keyTarget6)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget8.FromString(string(value9), tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget5.FinishField(keyTarget6, valueTarget8); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishMap(mapTarget5); err != nil {
return err
}
- valueTarget7, err := mapTarget4.FinishKeyStartField(keyTarget5)
- if err != nil {
- return err
- }
- if err := valueTarget7.FromString(string(value8), tt.NonOptional().Field(0).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget4.FinishField(keyTarget5, valueTarget7); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishMap(mapTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("By")
+ keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("By")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget11, err := fieldTarget10.StartMap(tt.NonOptional().Field(1).Type, len(m.By))
- if err != nil {
- return err
+ var var12 bool
+ if len(m.By) == 0 {
+ var12 = true
}
- for key13, value15 := range m.By {
- keyTarget12, err := mapTarget11.StartKey()
+ if var12 {
+ if err := fieldTarget11.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget13, err := fieldTarget11.StartMap(tt.NonOptional().Field(1).Type, len(m.By))
if err != nil {
return err
}
- if err := keyTarget12.FromUint(uint64(key13), tt.NonOptional().Field(1).Type.Key()); err != nil {
- return err
+ for key15, value17 := range m.By {
+ keyTarget14, err := mapTarget13.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget14.FromUint(uint64(key15), tt.NonOptional().Field(1).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget16, err := mapTarget13.FinishKeyStartField(keyTarget14)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget16.FromString(string(value17), tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget13.FinishField(keyTarget14, valueTarget16); err != nil {
+ return err
+ }
}
- valueTarget14, err := mapTarget11.FinishKeyStartField(keyTarget12)
- if err != nil {
- return err
- }
- if err := valueTarget14.FromString(string(value15), tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget11.FinishField(keyTarget12, valueTarget14); err != nil {
+ if err := fieldTarget11.FinishMap(mapTarget13); err != nil {
return err
}
}
- if err := fieldTarget10.FinishMap(mapTarget11); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
return err
}
}
- keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("U16")
+ keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("U16")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget18, err := fieldTarget17.StartMap(tt.NonOptional().Field(2).Type, len(m.U16))
- if err != nil {
- return err
+ var var20 bool
+ if len(m.U16) == 0 {
+ var20 = true
}
- for key20, value22 := range m.U16 {
- keyTarget19, err := mapTarget18.StartKey()
+ if var20 {
+ if err := fieldTarget19.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget21, err := fieldTarget19.StartMap(tt.NonOptional().Field(2).Type, len(m.U16))
if err != nil {
return err
}
- if err := keyTarget19.FromUint(uint64(key20), tt.NonOptional().Field(2).Type.Key()); err != nil {
- return err
+ for key23, value25 := range m.U16 {
+ keyTarget22, err := mapTarget21.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget22.FromUint(uint64(key23), tt.NonOptional().Field(2).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget24, err := mapTarget21.FinishKeyStartField(keyTarget22)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget24.FromString(string(value25), tt.NonOptional().Field(2).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget21.FinishField(keyTarget22, valueTarget24); err != nil {
+ return err
+ }
}
- valueTarget21, err := mapTarget18.FinishKeyStartField(keyTarget19)
- if err != nil {
- return err
- }
- if err := valueTarget21.FromString(string(value22), tt.NonOptional().Field(2).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget18.FinishField(keyTarget19, valueTarget21); err != nil {
+ if err := fieldTarget19.FinishMap(mapTarget21); err != nil {
return err
}
}
- if err := fieldTarget17.FinishMap(mapTarget18); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil {
return err
}
}
- keyTarget23, fieldTarget24, err := fieldsTarget1.StartField("U32")
+ keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("U32")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget25, err := fieldTarget24.StartMap(tt.NonOptional().Field(3).Type, len(m.U32))
- if err != nil {
- return err
+ var var28 bool
+ if len(m.U32) == 0 {
+ var28 = true
}
- for key27, value29 := range m.U32 {
- keyTarget26, err := mapTarget25.StartKey()
+ if var28 {
+ if err := fieldTarget27.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget29, err := fieldTarget27.StartMap(tt.NonOptional().Field(3).Type, len(m.U32))
if err != nil {
return err
}
- if err := keyTarget26.FromUint(uint64(key27), tt.NonOptional().Field(3).Type.Key()); err != nil {
- return err
+ for key31, value33 := range m.U32 {
+ keyTarget30, err := mapTarget29.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget30.FromUint(uint64(key31), tt.NonOptional().Field(3).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget32, err := mapTarget29.FinishKeyStartField(keyTarget30)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget32.FromString(string(value33), tt.NonOptional().Field(3).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget29.FinishField(keyTarget30, valueTarget32); err != nil {
+ return err
+ }
}
- valueTarget28, err := mapTarget25.FinishKeyStartField(keyTarget26)
- if err != nil {
- return err
- }
- if err := valueTarget28.FromString(string(value29), tt.NonOptional().Field(3).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget25.FinishField(keyTarget26, valueTarget28); err != nil {
+ if err := fieldTarget27.FinishMap(mapTarget29); err != nil {
return err
}
}
- if err := fieldTarget24.FinishMap(mapTarget25); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget23, fieldTarget24); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
return err
}
}
- keyTarget30, fieldTarget31, err := fieldsTarget1.StartField("U64")
+ keyTarget34, fieldTarget35, err := fieldsTarget1.StartField("U64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget32, err := fieldTarget31.StartMap(tt.NonOptional().Field(4).Type, len(m.U64))
- if err != nil {
- return err
+ var var36 bool
+ if len(m.U64) == 0 {
+ var36 = true
}
- for key34, value36 := range m.U64 {
- keyTarget33, err := mapTarget32.StartKey()
+ if var36 {
+ if err := fieldTarget35.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget37, err := fieldTarget35.StartMap(tt.NonOptional().Field(4).Type, len(m.U64))
if err != nil {
return err
}
- if err := keyTarget33.FromUint(uint64(key34), tt.NonOptional().Field(4).Type.Key()); err != nil {
- return err
+ for key39, value41 := range m.U64 {
+ keyTarget38, err := mapTarget37.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget38.FromUint(uint64(key39), tt.NonOptional().Field(4).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget40, err := mapTarget37.FinishKeyStartField(keyTarget38)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget40.FromString(string(value41), tt.NonOptional().Field(4).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget37.FinishField(keyTarget38, valueTarget40); err != nil {
+ return err
+ }
}
- valueTarget35, err := mapTarget32.FinishKeyStartField(keyTarget33)
- if err != nil {
- return err
- }
- if err := valueTarget35.FromString(string(value36), tt.NonOptional().Field(4).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget32.FinishField(keyTarget33, valueTarget35); err != nil {
+ if err := fieldTarget35.FinishMap(mapTarget37); err != nil {
return err
}
}
- if err := fieldTarget31.FinishMap(mapTarget32); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget30, fieldTarget31); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget34, fieldTarget35); err != nil {
return err
}
}
- keyTarget37, fieldTarget38, err := fieldsTarget1.StartField("I16")
+ keyTarget42, fieldTarget43, err := fieldsTarget1.StartField("I16")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget39, err := fieldTarget38.StartMap(tt.NonOptional().Field(5).Type, len(m.I16))
- if err != nil {
- return err
+ var var44 bool
+ if len(m.I16) == 0 {
+ var44 = true
}
- for key41, value43 := range m.I16 {
- keyTarget40, err := mapTarget39.StartKey()
+ if var44 {
+ if err := fieldTarget43.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget45, err := fieldTarget43.StartMap(tt.NonOptional().Field(5).Type, len(m.I16))
if err != nil {
return err
}
- if err := keyTarget40.FromInt(int64(key41), tt.NonOptional().Field(5).Type.Key()); err != nil {
- return err
+ for key47, value49 := range m.I16 {
+ keyTarget46, err := mapTarget45.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget46.FromInt(int64(key47), tt.NonOptional().Field(5).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget48, err := mapTarget45.FinishKeyStartField(keyTarget46)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget48.FromString(string(value49), tt.NonOptional().Field(5).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget45.FinishField(keyTarget46, valueTarget48); err != nil {
+ return err
+ }
}
- valueTarget42, err := mapTarget39.FinishKeyStartField(keyTarget40)
- if err != nil {
- return err
- }
- if err := valueTarget42.FromString(string(value43), tt.NonOptional().Field(5).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget39.FinishField(keyTarget40, valueTarget42); err != nil {
+ if err := fieldTarget43.FinishMap(mapTarget45); err != nil {
return err
}
}
- if err := fieldTarget38.FinishMap(mapTarget39); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget37, fieldTarget38); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget42, fieldTarget43); err != nil {
return err
}
}
- keyTarget44, fieldTarget45, err := fieldsTarget1.StartField("I32")
+ keyTarget50, fieldTarget51, err := fieldsTarget1.StartField("I32")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget46, err := fieldTarget45.StartMap(tt.NonOptional().Field(6).Type, len(m.I32))
- if err != nil {
- return err
+ var var52 bool
+ if len(m.I32) == 0 {
+ var52 = true
}
- for key48, value50 := range m.I32 {
- keyTarget47, err := mapTarget46.StartKey()
+ if var52 {
+ if err := fieldTarget51.FromZero(tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget53, err := fieldTarget51.StartMap(tt.NonOptional().Field(6).Type, len(m.I32))
if err != nil {
return err
}
- if err := keyTarget47.FromInt(int64(key48), tt.NonOptional().Field(6).Type.Key()); err != nil {
- return err
+ for key55, value57 := range m.I32 {
+ keyTarget54, err := mapTarget53.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget54.FromInt(int64(key55), tt.NonOptional().Field(6).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget56, err := mapTarget53.FinishKeyStartField(keyTarget54)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget56.FromString(string(value57), tt.NonOptional().Field(6).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget53.FinishField(keyTarget54, valueTarget56); err != nil {
+ return err
+ }
}
- valueTarget49, err := mapTarget46.FinishKeyStartField(keyTarget47)
- if err != nil {
- return err
- }
- if err := valueTarget49.FromString(string(value50), tt.NonOptional().Field(6).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget46.FinishField(keyTarget47, valueTarget49); err != nil {
+ if err := fieldTarget51.FinishMap(mapTarget53); err != nil {
return err
}
}
- if err := fieldTarget45.FinishMap(mapTarget46); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget44, fieldTarget45); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget50, fieldTarget51); err != nil {
return err
}
}
- keyTarget51, fieldTarget52, err := fieldsTarget1.StartField("I64")
+ keyTarget58, fieldTarget59, err := fieldsTarget1.StartField("I64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget53, err := fieldTarget52.StartMap(tt.NonOptional().Field(7).Type, len(m.I64))
- if err != nil {
- return err
+ var var60 bool
+ if len(m.I64) == 0 {
+ var60 = true
}
- for key55, value57 := range m.I64 {
- keyTarget54, err := mapTarget53.StartKey()
- if err != nil {
+ if var60 {
+ if err := fieldTarget59.FromZero(tt.NonOptional().Field(7).Type); err != nil {
return err
}
- if err := keyTarget54.FromInt(int64(key55), tt.NonOptional().Field(7).Type.Key()); err != nil {
- return err
- }
- valueTarget56, err := mapTarget53.FinishKeyStartField(keyTarget54)
- if err != nil {
- return err
- }
- if err := valueTarget56.FromString(string(value57), tt.NonOptional().Field(7).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget53.FinishField(keyTarget54, valueTarget56); err != nil {
- return err
- }
- }
- if err := fieldTarget52.FinishMap(mapTarget53); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget51, fieldTarget52); err != nil {
- return err
- }
- }
- keyTarget58, fieldTarget59, err := fieldsTarget1.StartField("F32")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
+ } else {
- mapTarget60, err := fieldTarget59.StartMap(tt.NonOptional().Field(8).Type, len(m.F32))
- if err != nil {
- return err
- }
- for key62, value64 := range m.F32 {
- keyTarget61, err := mapTarget60.StartKey()
+ mapTarget61, err := fieldTarget59.StartMap(tt.NonOptional().Field(7).Type, len(m.I64))
if err != nil {
return err
}
- if err := keyTarget61.FromFloat(float64(key62), tt.NonOptional().Field(8).Type.Key()); err != nil {
+ for key63, value65 := range m.I64 {
+ keyTarget62, err := mapTarget61.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget62.FromInt(int64(key63), tt.NonOptional().Field(7).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget64, err := mapTarget61.FinishKeyStartField(keyTarget62)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget64.FromString(string(value65), tt.NonOptional().Field(7).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget61.FinishField(keyTarget62, valueTarget64); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget59.FinishMap(mapTarget61); err != nil {
return err
}
- valueTarget63, err := mapTarget60.FinishKeyStartField(keyTarget61)
- if err != nil {
- return err
- }
- if err := valueTarget63.FromString(string(value64), tt.NonOptional().Field(8).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget60.FinishField(keyTarget61, valueTarget63); err != nil {
- return err
- }
- }
- if err := fieldTarget59.FinishMap(mapTarget60); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget58, fieldTarget59); err != nil {
return err
}
}
- keyTarget65, fieldTarget66, err := fieldsTarget1.StartField("F64")
+ keyTarget66, fieldTarget67, err := fieldsTarget1.StartField("F32")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget67, err := fieldTarget66.StartMap(tt.NonOptional().Field(9).Type, len(m.F64))
- if err != nil {
- return err
+ var var68 bool
+ if len(m.F32) == 0 {
+ var68 = true
}
- for key69, value71 := range m.F64 {
- keyTarget68, err := mapTarget67.StartKey()
- if err != nil {
+ if var68 {
+ if err := fieldTarget67.FromZero(tt.NonOptional().Field(8).Type); err != nil {
return err
}
- if err := keyTarget68.FromFloat(float64(key69), tt.NonOptional().Field(9).Type.Key()); err != nil {
- return err
- }
- valueTarget70, err := mapTarget67.FinishKeyStartField(keyTarget68)
- if err != nil {
- return err
- }
- if err := valueTarget70.FromString(string(value71), tt.NonOptional().Field(9).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget67.FinishField(keyTarget68, valueTarget70); err != nil {
- return err
- }
- }
- if err := fieldTarget66.FinishMap(mapTarget67); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget65, fieldTarget66); err != nil {
- return err
- }
- }
- keyTarget72, fieldTarget73, err := fieldsTarget1.StartField("S")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
+ } else {
- mapTarget74, err := fieldTarget73.StartMap(tt.NonOptional().Field(10).Type, len(m.S))
- if err != nil {
- return err
- }
- for key76, value78 := range m.S {
- keyTarget75, err := mapTarget74.StartKey()
+ mapTarget69, err := fieldTarget67.StartMap(tt.NonOptional().Field(8).Type, len(m.F32))
if err != nil {
return err
}
- if err := keyTarget75.FromString(string(key76), tt.NonOptional().Field(10).Type.Key()); err != nil {
- return err
- }
- valueTarget77, err := mapTarget74.FinishKeyStartField(keyTarget75)
- if err != nil {
- return err
- }
- if err := valueTarget77.FromString(string(value78), tt.NonOptional().Field(10).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget74.FinishField(keyTarget75, valueTarget77); err != nil {
- return err
- }
- }
- if err := fieldTarget73.FinishMap(mapTarget74); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget72, fieldTarget73); err != nil {
- return err
- }
- }
- keyTarget79, fieldTarget80, err := fieldsTarget1.StartField("Ms")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
-
- mapTarget81, err := fieldTarget80.StartMap(tt.NonOptional().Field(11).Type, len(m.Ms))
- if err != nil {
- return err
- }
- for key83, value85 := range m.Ms {
- keyTarget82, err := mapTarget81.StartKey()
- if err != nil {
- return err
- }
- if err := keyTarget82.FromString(string(key83), tt.NonOptional().Field(11).Type.Key()); err != nil {
- return err
- }
- valueTarget84, err := mapTarget81.FinishKeyStartField(keyTarget82)
- if err != nil {
- return err
- }
-
- mapTarget86, err := valueTarget84.StartMap(tt.NonOptional().Field(11).Type.Elem(), len(value85))
- if err != nil {
- return err
- }
- for key88, value90 := range value85 {
- keyTarget87, err := mapTarget86.StartKey()
+ for key71, value73 := range m.F32 {
+ keyTarget70, err := mapTarget69.StartKey()
if err != nil {
return err
}
- if err := keyTarget87.FromString(string(key88), tt.NonOptional().Field(11).Type.Elem().Key()); err != nil {
+ if err := keyTarget70.FromFloat(float64(key71), tt.NonOptional().Field(8).Type.Key()); err != nil {
return err
}
- valueTarget89, err := mapTarget86.FinishKeyStartField(keyTarget87)
+ valueTarget72, err := mapTarget69.FinishKeyStartField(keyTarget70)
if err != nil {
return err
}
- if err := valueTarget89.FromString(string(value90), tt.NonOptional().Field(11).Type.Elem().Elem()); err != nil {
+ if err := valueTarget72.FromString(string(value73), tt.NonOptional().Field(8).Type.Elem()); err != nil {
return err
}
- if err := mapTarget86.FinishField(keyTarget87, valueTarget89); err != nil {
+ if err := mapTarget69.FinishField(keyTarget70, valueTarget72); err != nil {
return err
}
}
- if err := valueTarget84.FinishMap(mapTarget86); err != nil {
- return err
- }
- if err := mapTarget81.FinishField(keyTarget82, valueTarget84); err != nil {
+ if err := fieldTarget67.FinishMap(mapTarget69); err != nil {
return err
}
}
- if err := fieldTarget80.FinishMap(mapTarget81); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget79, fieldTarget80); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget66, fieldTarget67); err != nil {
return err
}
}
- keyTarget91, fieldTarget92, err := fieldsTarget1.StartField("T")
+ keyTarget74, fieldTarget75, err := fieldsTarget1.StartField("F64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget93, err := fieldTarget92.StartMap(tt.NonOptional().Field(12).Type, len(m.T))
- if err != nil {
- return err
+ var var76 bool
+ if len(m.F64) == 0 {
+ var76 = true
}
- for key95, value97 := range m.T {
- keyTarget94, err := mapTarget93.StartKey()
+ if var76 {
+ if err := fieldTarget75.FromZero(tt.NonOptional().Field(9).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget77, err := fieldTarget75.StartMap(tt.NonOptional().Field(9).Type, len(m.F64))
if err != nil {
return err
}
-
- var wireValue98 time_2.Time
- if err := time_2.TimeFromNative(&wireValue98, key95); err != nil {
+ for key79, value81 := range m.F64 {
+ keyTarget78, err := mapTarget77.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget78.FromFloat(float64(key79), tt.NonOptional().Field(9).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget80, err := mapTarget77.FinishKeyStartField(keyTarget78)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget80.FromString(string(value81), tt.NonOptional().Field(9).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget77.FinishField(keyTarget78, valueTarget80); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget75.FinishMap(mapTarget77); err != nil {
return err
}
+ }
+ if err := fieldsTarget1.FinishField(keyTarget74, fieldTarget75); err != nil {
+ return err
+ }
+ }
+ keyTarget82, fieldTarget83, err := fieldsTarget1.StartField("S")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
- if err := wireValue98.FillVDLTarget(keyTarget94, tt.NonOptional().Field(12).Type.Key()); err != nil {
+ var var84 bool
+ if len(m.S) == 0 {
+ var84 = true
+ }
+ if var84 {
+ if err := fieldTarget83.FromZero(tt.NonOptional().Field(10).Type); err != nil {
return err
}
- valueTarget96, err := mapTarget93.FinishKeyStartField(keyTarget94)
+ } else {
+
+ mapTarget85, err := fieldTarget83.StartMap(tt.NonOptional().Field(10).Type, len(m.S))
if err != nil {
return err
}
- if err := valueTarget96.FromString(string(value97), tt.NonOptional().Field(12).Type.Elem()); err != nil {
- return err
+ for key87, value89 := range m.S {
+ keyTarget86, err := mapTarget85.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget86.FromString(string(key87), tt.NonOptional().Field(10).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget88, err := mapTarget85.FinishKeyStartField(keyTarget86)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget88.FromString(string(value89), tt.NonOptional().Field(10).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget85.FinishField(keyTarget86, valueTarget88); err != nil {
+ return err
+ }
}
- if err := mapTarget93.FinishField(keyTarget94, valueTarget96); err != nil {
+ if err := fieldTarget83.FinishMap(mapTarget85); err != nil {
return err
}
}
- if err := fieldTarget92.FinishMap(mapTarget93); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget82, fieldTarget83); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget91, fieldTarget92); err != nil {
+ }
+ keyTarget90, fieldTarget91, err := fieldsTarget1.StartField("Ms")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var92 bool
+ if len(m.Ms) == 0 {
+ var92 = true
+ }
+ if var92 {
+ if err := fieldTarget91.FromZero(tt.NonOptional().Field(11).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget93, err := fieldTarget91.StartMap(tt.NonOptional().Field(11).Type, len(m.Ms))
+ if err != nil {
+ return err
+ }
+ for key95, value97 := range m.Ms {
+ keyTarget94, err := mapTarget93.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget94.FromString(string(key95), tt.NonOptional().Field(11).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget96, err := mapTarget93.FinishKeyStartField(keyTarget94)
+ if err != nil {
+ return err
+ }
+
+ mapTarget98, err := valueTarget96.StartMap(tt.NonOptional().Field(11).Type.Elem(), len(value97))
+ if err != nil {
+ return err
+ }
+ for key100, value102 := range value97 {
+ keyTarget99, err := mapTarget98.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget99.FromString(string(key100), tt.NonOptional().Field(11).Type.Elem().Key()); err != nil {
+ return err
+ }
+ valueTarget101, err := mapTarget98.FinishKeyStartField(keyTarget99)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget101.FromString(string(value102), tt.NonOptional().Field(11).Type.Elem().Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget98.FinishField(keyTarget99, valueTarget101); err != nil {
+ return err
+ }
+ }
+ if err := valueTarget96.FinishMap(mapTarget98); err != nil {
+ return err
+ }
+ if err := mapTarget93.FinishField(keyTarget94, valueTarget96); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget91.FinishMap(mapTarget93); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget90, fieldTarget91); err != nil {
+ return err
+ }
+ }
+ keyTarget103, fieldTarget104, err := fieldsTarget1.StartField("T")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var105 bool
+ if len(m.T) == 0 {
+ var105 = true
+ }
+ if var105 {
+ if err := fieldTarget104.FromZero(tt.NonOptional().Field(12).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget106, err := fieldTarget104.StartMap(tt.NonOptional().Field(12).Type, len(m.T))
+ if err != nil {
+ return err
+ }
+ for key108, value110 := range m.T {
+ keyTarget107, err := mapTarget106.StartKey()
+ if err != nil {
+ return err
+ }
+
+ var wireValue111 time_2.Time
+ if err := time_2.TimeFromNative(&wireValue111, key108); err != nil {
+ return err
+ }
+
+ if err := wireValue111.FillVDLTarget(keyTarget107, tt.NonOptional().Field(12).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget109, err := mapTarget106.FinishKeyStartField(keyTarget107)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget109.FromString(string(value110), tt.NonOptional().Field(12).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget106.FinishField(keyTarget107, valueTarget109); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget104.FinishMap(mapTarget106); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget103, fieldTarget104); err != nil {
return err
}
}
@@ -3326,6 +3994,10 @@
return nil
}
+func (t *ManyMapsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ManyMaps{}
+ return nil
+}
// map[bool]string
type __VDLTarget8_map struct {
@@ -3369,6 +4041,10 @@
return nil
}
+func (t *__VDLTarget8_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[bool]string(nil)
+ return nil
+}
// map[byte]string
type __VDLTarget9_map struct {
@@ -3412,6 +4088,10 @@
return nil
}
+func (t *__VDLTarget9_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[byte]string(nil)
+ return nil
+}
// map[uint16]string
type __VDLTarget10_map struct {
@@ -3455,6 +4135,10 @@
return nil
}
+func (t *__VDLTarget10_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[uint16]string(nil)
+ return nil
+}
// map[uint32]string
type __VDLTarget11_map struct {
@@ -3498,6 +4182,10 @@
return nil
}
+func (t *__VDLTarget11_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[uint32]string(nil)
+ return nil
+}
// map[uint64]string
type __VDLTarget12_map struct {
@@ -3541,6 +4229,10 @@
return nil
}
+func (t *__VDLTarget12_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[uint64]string(nil)
+ return nil
+}
// map[int16]string
type __VDLTarget13_map struct {
@@ -3584,6 +4276,10 @@
return nil
}
+func (t *__VDLTarget13_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[int16]string(nil)
+ return nil
+}
// map[int32]string
type __VDLTarget14_map struct {
@@ -3627,6 +4323,10 @@
return nil
}
+func (t *__VDLTarget14_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[int32]string(nil)
+ return nil
+}
// map[int64]string
type __VDLTarget15_map struct {
@@ -3670,6 +4370,10 @@
return nil
}
+func (t *__VDLTarget15_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[int64]string(nil)
+ return nil
+}
// map[float32]string
type __VDLTarget16_map struct {
@@ -3713,6 +4417,10 @@
return nil
}
+func (t *__VDLTarget16_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[float32]string(nil)
+ return nil
+}
// map[float64]string
type __VDLTarget17_map struct {
@@ -3756,6 +4464,10 @@
return nil
}
+func (t *__VDLTarget17_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[float64]string(nil)
+ return nil
+}
// map[string]string
type __VDLTarget18_map struct {
@@ -3799,6 +4511,10 @@
return nil
}
+func (t *__VDLTarget18_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[string]string(nil)
+ return nil
+}
// map[string]map[string]string
type __VDLTarget19_map struct {
@@ -3842,6 +4558,10 @@
return nil
}
+func (t *__VDLTarget19_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[string]map[string]string(nil)
+ return nil
+}
// map[time.Time]string
type __VDLTarget20_map struct {
@@ -3885,6 +4605,10 @@
return nil
}
+func (t *__VDLTarget20_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[time.Time]string(nil)
+ return nil
+}
type ManySets struct {
B map[bool]struct{}
@@ -3911,358 +4635,489 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget4, err := fieldTarget3.StartSet(tt.NonOptional().Field(0).Type, len(m.B))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.B) == 0 {
+ var4 = true
}
- for key6 := range m.B {
- keyTarget5, err := setTarget4.StartKey()
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget5, err := fieldTarget3.StartSet(tt.NonOptional().Field(0).Type, len(m.B))
if err != nil {
return err
}
- if err := keyTarget5.FromBool(bool(key6), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ for key7 := range m.B {
+ keyTarget6, err := setTarget5.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget6.FromBool(bool(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget5.FinishKey(keyTarget6); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishSet(setTarget5); err != nil {
return err
}
- if err := setTarget4.FinishKey(keyTarget5); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishSet(setTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("By")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("By")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget9, err := fieldTarget8.StartSet(tt.NonOptional().Field(1).Type, len(m.By))
- if err != nil {
- return err
+ var var10 bool
+ if len(m.By) == 0 {
+ var10 = true
}
- for key11 := range m.By {
- keyTarget10, err := setTarget9.StartKey()
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget11, err := fieldTarget9.StartSet(tt.NonOptional().Field(1).Type, len(m.By))
if err != nil {
return err
}
- if err := keyTarget10.FromUint(uint64(key11), tt.NonOptional().Field(1).Type.Key()); err != nil {
- return err
+ for key13 := range m.By {
+ keyTarget12, err := setTarget11.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget12.FromUint(uint64(key13), tt.NonOptional().Field(1).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget11.FinishKey(keyTarget12); err != nil {
+ return err
+ }
}
- if err := setTarget9.FinishKey(keyTarget10); err != nil {
+ if err := fieldTarget9.FinishSet(setTarget11); err != nil {
return err
}
}
- if err := fieldTarget8.FinishSet(setTarget9); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("U16")
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("U16")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget14, err := fieldTarget13.StartSet(tt.NonOptional().Field(2).Type, len(m.U16))
- if err != nil {
- return err
+ var var16 bool
+ if len(m.U16) == 0 {
+ var16 = true
}
- for key16 := range m.U16 {
- keyTarget15, err := setTarget14.StartKey()
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget17, err := fieldTarget15.StartSet(tt.NonOptional().Field(2).Type, len(m.U16))
if err != nil {
return err
}
- if err := keyTarget15.FromUint(uint64(key16), tt.NonOptional().Field(2).Type.Key()); err != nil {
- return err
+ for key19 := range m.U16 {
+ keyTarget18, err := setTarget17.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget18.FromUint(uint64(key19), tt.NonOptional().Field(2).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget17.FinishKey(keyTarget18); err != nil {
+ return err
+ }
}
- if err := setTarget14.FinishKey(keyTarget15); err != nil {
+ if err := fieldTarget15.FinishSet(setTarget17); err != nil {
return err
}
}
- if err := fieldTarget13.FinishSet(setTarget14); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
- keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("U32")
+ keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("U32")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget19, err := fieldTarget18.StartSet(tt.NonOptional().Field(3).Type, len(m.U32))
- if err != nil {
- return err
+ var var22 bool
+ if len(m.U32) == 0 {
+ var22 = true
}
- for key21 := range m.U32 {
- keyTarget20, err := setTarget19.StartKey()
+ if var22 {
+ if err := fieldTarget21.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget23, err := fieldTarget21.StartSet(tt.NonOptional().Field(3).Type, len(m.U32))
if err != nil {
return err
}
- if err := keyTarget20.FromUint(uint64(key21), tt.NonOptional().Field(3).Type.Key()); err != nil {
- return err
+ for key25 := range m.U32 {
+ keyTarget24, err := setTarget23.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget24.FromUint(uint64(key25), tt.NonOptional().Field(3).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget23.FinishKey(keyTarget24); err != nil {
+ return err
+ }
}
- if err := setTarget19.FinishKey(keyTarget20); err != nil {
+ if err := fieldTarget21.FinishSet(setTarget23); err != nil {
return err
}
}
- if err := fieldTarget18.FinishSet(setTarget19); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
return err
}
}
- keyTarget22, fieldTarget23, err := fieldsTarget1.StartField("U64")
+ keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("U64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget24, err := fieldTarget23.StartSet(tt.NonOptional().Field(4).Type, len(m.U64))
- if err != nil {
- return err
+ var var28 bool
+ if len(m.U64) == 0 {
+ var28 = true
}
- for key26 := range m.U64 {
- keyTarget25, err := setTarget24.StartKey()
+ if var28 {
+ if err := fieldTarget27.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget29, err := fieldTarget27.StartSet(tt.NonOptional().Field(4).Type, len(m.U64))
if err != nil {
return err
}
- if err := keyTarget25.FromUint(uint64(key26), tt.NonOptional().Field(4).Type.Key()); err != nil {
- return err
+ for key31 := range m.U64 {
+ keyTarget30, err := setTarget29.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget30.FromUint(uint64(key31), tt.NonOptional().Field(4).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget29.FinishKey(keyTarget30); err != nil {
+ return err
+ }
}
- if err := setTarget24.FinishKey(keyTarget25); err != nil {
+ if err := fieldTarget27.FinishSet(setTarget29); err != nil {
return err
}
}
- if err := fieldTarget23.FinishSet(setTarget24); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget22, fieldTarget23); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
return err
}
}
- keyTarget27, fieldTarget28, err := fieldsTarget1.StartField("I16")
+ keyTarget32, fieldTarget33, err := fieldsTarget1.StartField("I16")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget29, err := fieldTarget28.StartSet(tt.NonOptional().Field(5).Type, len(m.I16))
- if err != nil {
- return err
+ var var34 bool
+ if len(m.I16) == 0 {
+ var34 = true
}
- for key31 := range m.I16 {
- keyTarget30, err := setTarget29.StartKey()
- if err != nil {
+ if var34 {
+ if err := fieldTarget33.FromZero(tt.NonOptional().Field(5).Type); err != nil {
return err
}
- if err := keyTarget30.FromInt(int64(key31), tt.NonOptional().Field(5).Type.Key()); err != nil {
- return err
- }
- if err := setTarget29.FinishKey(keyTarget30); err != nil {
- return err
- }
- }
- if err := fieldTarget28.FinishSet(setTarget29); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget27, fieldTarget28); err != nil {
- return err
- }
- }
- keyTarget32, fieldTarget33, err := fieldsTarget1.StartField("I32")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
+ } else {
- setTarget34, err := fieldTarget33.StartSet(tt.NonOptional().Field(6).Type, len(m.I32))
- if err != nil {
- return err
- }
- for key36 := range m.I32 {
- keyTarget35, err := setTarget34.StartKey()
+ setTarget35, err := fieldTarget33.StartSet(tt.NonOptional().Field(5).Type, len(m.I16))
if err != nil {
return err
}
- if err := keyTarget35.FromInt(int64(key36), tt.NonOptional().Field(6).Type.Key()); err != nil {
+ for key37 := range m.I16 {
+ keyTarget36, err := setTarget35.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget36.FromInt(int64(key37), tt.NonOptional().Field(5).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget35.FinishKey(keyTarget36); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget33.FinishSet(setTarget35); err != nil {
return err
}
- if err := setTarget34.FinishKey(keyTarget35); err != nil {
- return err
- }
- }
- if err := fieldTarget33.FinishSet(setTarget34); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget32, fieldTarget33); err != nil {
return err
}
}
- keyTarget37, fieldTarget38, err := fieldsTarget1.StartField("I64")
+ keyTarget38, fieldTarget39, err := fieldsTarget1.StartField("I32")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget39, err := fieldTarget38.StartSet(tt.NonOptional().Field(7).Type, len(m.I64))
- if err != nil {
- return err
+ var var40 bool
+ if len(m.I32) == 0 {
+ var40 = true
}
- for key41 := range m.I64 {
- keyTarget40, err := setTarget39.StartKey()
+ if var40 {
+ if err := fieldTarget39.FromZero(tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget41, err := fieldTarget39.StartSet(tt.NonOptional().Field(6).Type, len(m.I32))
if err != nil {
return err
}
- if err := keyTarget40.FromInt(int64(key41), tt.NonOptional().Field(7).Type.Key()); err != nil {
- return err
+ for key43 := range m.I32 {
+ keyTarget42, err := setTarget41.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget42.FromInt(int64(key43), tt.NonOptional().Field(6).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget41.FinishKey(keyTarget42); err != nil {
+ return err
+ }
}
- if err := setTarget39.FinishKey(keyTarget40); err != nil {
+ if err := fieldTarget39.FinishSet(setTarget41); err != nil {
return err
}
}
- if err := fieldTarget38.FinishSet(setTarget39); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget37, fieldTarget38); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget38, fieldTarget39); err != nil {
return err
}
}
- keyTarget42, fieldTarget43, err := fieldsTarget1.StartField("F32")
+ keyTarget44, fieldTarget45, err := fieldsTarget1.StartField("I64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget44, err := fieldTarget43.StartSet(tt.NonOptional().Field(8).Type, len(m.F32))
- if err != nil {
- return err
+ var var46 bool
+ if len(m.I64) == 0 {
+ var46 = true
}
- for key46 := range m.F32 {
- keyTarget45, err := setTarget44.StartKey()
+ if var46 {
+ if err := fieldTarget45.FromZero(tt.NonOptional().Field(7).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget47, err := fieldTarget45.StartSet(tt.NonOptional().Field(7).Type, len(m.I64))
if err != nil {
return err
}
- if err := keyTarget45.FromFloat(float64(key46), tt.NonOptional().Field(8).Type.Key()); err != nil {
- return err
+ for key49 := range m.I64 {
+ keyTarget48, err := setTarget47.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget48.FromInt(int64(key49), tt.NonOptional().Field(7).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget47.FinishKey(keyTarget48); err != nil {
+ return err
+ }
}
- if err := setTarget44.FinishKey(keyTarget45); err != nil {
+ if err := fieldTarget45.FinishSet(setTarget47); err != nil {
return err
}
}
- if err := fieldTarget43.FinishSet(setTarget44); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget42, fieldTarget43); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget44, fieldTarget45); err != nil {
return err
}
}
- keyTarget47, fieldTarget48, err := fieldsTarget1.StartField("F64")
+ keyTarget50, fieldTarget51, err := fieldsTarget1.StartField("F32")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget49, err := fieldTarget48.StartSet(tt.NonOptional().Field(9).Type, len(m.F64))
- if err != nil {
- return err
+ var var52 bool
+ if len(m.F32) == 0 {
+ var52 = true
}
- for key51 := range m.F64 {
- keyTarget50, err := setTarget49.StartKey()
+ if var52 {
+ if err := fieldTarget51.FromZero(tt.NonOptional().Field(8).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget53, err := fieldTarget51.StartSet(tt.NonOptional().Field(8).Type, len(m.F32))
if err != nil {
return err
}
- if err := keyTarget50.FromFloat(float64(key51), tt.NonOptional().Field(9).Type.Key()); err != nil {
- return err
+ for key55 := range m.F32 {
+ keyTarget54, err := setTarget53.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget54.FromFloat(float64(key55), tt.NonOptional().Field(8).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget53.FinishKey(keyTarget54); err != nil {
+ return err
+ }
}
- if err := setTarget49.FinishKey(keyTarget50); err != nil {
+ if err := fieldTarget51.FinishSet(setTarget53); err != nil {
return err
}
}
- if err := fieldTarget48.FinishSet(setTarget49); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget47, fieldTarget48); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget50, fieldTarget51); err != nil {
return err
}
}
- keyTarget52, fieldTarget53, err := fieldsTarget1.StartField("S")
+ keyTarget56, fieldTarget57, err := fieldsTarget1.StartField("F64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget54, err := fieldTarget53.StartSet(tt.NonOptional().Field(10).Type, len(m.S))
- if err != nil {
- return err
+ var var58 bool
+ if len(m.F64) == 0 {
+ var58 = true
}
- for key56 := range m.S {
- keyTarget55, err := setTarget54.StartKey()
+ if var58 {
+ if err := fieldTarget57.FromZero(tt.NonOptional().Field(9).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget59, err := fieldTarget57.StartSet(tt.NonOptional().Field(9).Type, len(m.F64))
if err != nil {
return err
}
- if err := keyTarget55.FromString(string(key56), tt.NonOptional().Field(10).Type.Key()); err != nil {
- return err
+ for key61 := range m.F64 {
+ keyTarget60, err := setTarget59.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget60.FromFloat(float64(key61), tt.NonOptional().Field(9).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget59.FinishKey(keyTarget60); err != nil {
+ return err
+ }
}
- if err := setTarget54.FinishKey(keyTarget55); err != nil {
+ if err := fieldTarget57.FinishSet(setTarget59); err != nil {
return err
}
}
- if err := fieldTarget53.FinishSet(setTarget54); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget52, fieldTarget53); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget56, fieldTarget57); err != nil {
return err
}
}
- keyTarget57, fieldTarget58, err := fieldsTarget1.StartField("T")
+ keyTarget62, fieldTarget63, err := fieldsTarget1.StartField("S")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget59, err := fieldTarget58.StartSet(tt.NonOptional().Field(11).Type, len(m.T))
- if err != nil {
- return err
+ var var64 bool
+ if len(m.S) == 0 {
+ var64 = true
}
- for key61 := range m.T {
- keyTarget60, err := setTarget59.StartKey()
+ if var64 {
+ if err := fieldTarget63.FromZero(tt.NonOptional().Field(10).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget65, err := fieldTarget63.StartSet(tt.NonOptional().Field(10).Type, len(m.S))
if err != nil {
return err
}
-
- var wireValue62 time_2.Time
- if err := time_2.TimeFromNative(&wireValue62, key61); err != nil {
- return err
+ for key67 := range m.S {
+ keyTarget66, err := setTarget65.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget66.FromString(string(key67), tt.NonOptional().Field(10).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget65.FinishKey(keyTarget66); err != nil {
+ return err
+ }
}
-
- if err := wireValue62.FillVDLTarget(keyTarget60, tt.NonOptional().Field(11).Type.Key()); err != nil {
- return err
- }
- if err := setTarget59.FinishKey(keyTarget60); err != nil {
+ if err := fieldTarget63.FinishSet(setTarget65); err != nil {
return err
}
}
- if err := fieldTarget58.FinishSet(setTarget59); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget62, fieldTarget63); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget57, fieldTarget58); err != nil {
+ }
+ keyTarget68, fieldTarget69, err := fieldsTarget1.StartField("T")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var70 bool
+ if len(m.T) == 0 {
+ var70 = true
+ }
+ if var70 {
+ if err := fieldTarget69.FromZero(tt.NonOptional().Field(11).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget71, err := fieldTarget69.StartSet(tt.NonOptional().Field(11).Type, len(m.T))
+ if err != nil {
+ return err
+ }
+ for key73 := range m.T {
+ keyTarget72, err := setTarget71.StartKey()
+ if err != nil {
+ return err
+ }
+
+ var wireValue74 time_2.Time
+ if err := time_2.TimeFromNative(&wireValue74, key73); err != nil {
+ return err
+ }
+
+ if err := wireValue74.FillVDLTarget(keyTarget72, tt.NonOptional().Field(11).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget71.FinishKey(keyTarget72); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget69.FinishSet(setTarget71); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget68, fieldTarget69); err != nil {
return err
}
}
@@ -4362,6 +5217,10 @@
return nil
}
+func (t *ManySetsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ManySets{}
+ return nil
+}
// map[bool]struct{}
type __VDLTarget21_set struct {
@@ -4397,6 +5256,10 @@
return nil
}
+func (t *__VDLTarget21_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[bool]struct{}(nil)
+ return nil
+}
// map[byte]struct{}
type __VDLTarget22_set struct {
@@ -4432,6 +5295,10 @@
return nil
}
+func (t *__VDLTarget22_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[byte]struct{}(nil)
+ return nil
+}
// map[uint16]struct{}
type __VDLTarget23_set struct {
@@ -4467,6 +5334,10 @@
return nil
}
+func (t *__VDLTarget23_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[uint16]struct{}(nil)
+ return nil
+}
// map[uint32]struct{}
type __VDLTarget24_set struct {
@@ -4502,6 +5373,10 @@
return nil
}
+func (t *__VDLTarget24_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[uint32]struct{}(nil)
+ return nil
+}
// map[uint64]struct{}
type __VDLTarget25_set struct {
@@ -4537,6 +5412,10 @@
return nil
}
+func (t *__VDLTarget25_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[uint64]struct{}(nil)
+ return nil
+}
// map[int16]struct{}
type __VDLTarget26_set struct {
@@ -4572,6 +5451,10 @@
return nil
}
+func (t *__VDLTarget26_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[int16]struct{}(nil)
+ return nil
+}
// map[int32]struct{}
type __VDLTarget27_set struct {
@@ -4607,6 +5490,10 @@
return nil
}
+func (t *__VDLTarget27_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[int32]struct{}(nil)
+ return nil
+}
// map[int64]struct{}
type __VDLTarget28_set struct {
@@ -4642,6 +5529,10 @@
return nil
}
+func (t *__VDLTarget28_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[int64]struct{}(nil)
+ return nil
+}
// map[float32]struct{}
type __VDLTarget29_set struct {
@@ -4677,6 +5568,10 @@
return nil
}
+func (t *__VDLTarget29_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[float32]struct{}(nil)
+ return nil
+}
// map[float64]struct{}
type __VDLTarget30_set struct {
@@ -4712,6 +5607,10 @@
return nil
}
+func (t *__VDLTarget30_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[float64]struct{}(nil)
+ return nil
+}
// map[time.Time]struct{}
type __VDLTarget31_set struct {
@@ -4747,6 +5646,10 @@
return nil
}
+func (t *__VDLTarget31_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[time.Time]struct{}(nil)
+ return nil
+}
type BigData struct {
Key string // A dup of the key stored in the value.
@@ -4762,14 +5665,21 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Key == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -4816,55 +5726,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroAddressInfo = AddressInfo{}
- __VDLZeroCreditAgency = CreditAgencyEquifax
- __VDLZeroExperianRating = ExperianRatingGood
- __VDLZeroRatingsArray = RatingsArray{}
- __VDLZeroEquifaxCreditReport = EquifaxCreditReport{}
- __VDLZeroTdh = TdhTom
- __VDLZeroExperianCreditReport = ExperianCreditReport{}
- __VDLZeroTransUnionCreditReport = TransUnionCreditReport{}
- __VDLZeroAgencyReport = AgencyReport(AgencyReportEquifaxReport{})
- __VDLZeroCreditReport = CreditReport{
- Report: AgencyReportEquifaxReport{},
- }
- __VDLZeroCustomer = Customer{
- Credit: CreditReport{
- Report: AgencyReportEquifaxReport{},
- },
- }
- __VDLZeroInvoice = Invoice{}
- __VDLZeroNumbers = Numbers{}
- __VDLZeroTitleOrValueType = TitleOrValueType(TitleOrValueTypeTitle{})
- __VDLZeroBazType = BazType{
- TitleOrValue: TitleOrValueTypeTitle{},
- }
- __VDLZeroBarType = BarType{
- Baz: BazType{
- TitleOrValue: TitleOrValueTypeTitle{},
- },
- }
- __VDLZeroFooType = FooType{
- Bar: BarType{
- Baz: BazType{
- TitleOrValue: TitleOrValueTypeTitle{},
- },
- },
- }
- __VDLZeroK = K{}
- __VDLZeroV = V{}
- __VDLZeroFunWithMaps = FunWithMaps{}
- __VDLZeroFunWithTypes = FunWithTypes{
- T1: vdl.AnyType,
- T2: vdl.AnyType,
- }
- __VDLZeroManyMaps = ManyMaps{}
- __VDLZeroManySets = ManySets{}
- __VDLZeroBigData = BigData{}
-)
+func (t *BigDataTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BigData{}
+ return nil
+}
var __VDLInitCalled bool
@@ -4885,6 +5750,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*AddressInfo)(nil))
diff --git a/query/syncql/.api b/query/syncql/.api
index 6a25eb9..9a0794d 100644
--- a/query/syncql/.api
+++ b/query/syncql/.api
@@ -60,59 +60,59 @@
pkg syncql, type ResultStream interface, Cancel()
pkg syncql, type ResultStream interface, Err() error
pkg syncql, type ResultStream interface, Result() []*vom.RawBytes
-pkg syncql, var ErrArgMustBeField verror.IDAction
-pkg syncql, var ErrBadFieldInWhere verror.IDAction
-pkg syncql, var ErrBigIntConversionError verror.IDAction
-pkg syncql, var ErrBigRatConversionError verror.IDAction
-pkg syncql, var ErrBoolConversionError verror.IDAction
-pkg syncql, var ErrBoolInvalidExpression verror.IDAction
-pkg syncql, var ErrCheckOfUnknownStatementType verror.IDAction
-pkg syncql, var ErrComplexConversionError verror.IDAction
-pkg syncql, var ErrCouldNotConvert verror.IDAction
-pkg syncql, var ErrDidYouMeanFunction verror.IDAction
-pkg syncql, var ErrDidYouMeanLowercaseK verror.IDAction
-pkg syncql, var ErrDidYouMeanLowercaseV verror.IDAction
-pkg syncql, var ErrDotNotationDisallowedForKey verror.IDAction
-pkg syncql, var ErrErrorCompilingRegularExpression verror.IDAction
-pkg syncql, var ErrExecOfUnknownStatementType verror.IDAction
-pkg syncql, var ErrExpected verror.IDAction
-pkg syncql, var ErrExpectedFrom verror.IDAction
-pkg syncql, var ErrExpectedIdentifier verror.IDAction
-pkg syncql, var ErrExpectedOperand verror.IDAction
-pkg syncql, var ErrExpectedOperator verror.IDAction
-pkg syncql, var ErrFloatConversionError verror.IDAction
-pkg syncql, var ErrFunctionArgBad verror.IDAction
-pkg syncql, var ErrFunctionArgCount verror.IDAction
-pkg syncql, var ErrFunctionAtLeastArgCount verror.IDAction
-pkg syncql, var ErrFunctionLenInvalidArg verror.IDAction
-pkg syncql, var ErrFunctionNotFound verror.IDAction
-pkg syncql, var ErrFunctionTypeInvalidArg verror.IDAction
-pkg syncql, var ErrIndexKindNotSupported verror.IDAction
-pkg syncql, var ErrIntConversionError verror.IDAction
-pkg syncql, var ErrInvalidEscapeChar verror.IDAction
-pkg syncql, var ErrInvalidEscapeSequence verror.IDAction
-pkg syncql, var ErrInvalidIndexField verror.IDAction
-pkg syncql, var ErrInvalidSelectField verror.IDAction
-pkg syncql, var ErrIsIsNotRequireLhsValue verror.IDAction
-pkg syncql, var ErrIsIsNotRequireRhsNil verror.IDAction
-pkg syncql, var ErrKeyExpressionLiteral verror.IDAction
-pkg syncql, var ErrKeyValueStreamError verror.IDAction
-pkg syncql, var ErrLikeExpressionsRequireRhsString verror.IDAction
-pkg syncql, var ErrLimitMustBeGt0 verror.IDAction
-pkg syncql, var ErrLocationConversionError verror.IDAction
-pkg syncql, var ErrMaxStatementLenExceeded verror.IDAction
-pkg syncql, var ErrNoStatementFound verror.IDAction
-pkg syncql, var ErrNotEnoughParamValuesSpecified verror.IDAction
-pkg syncql, var ErrNotWritable verror.IDAction
-pkg syncql, var ErrOffsetMustBeGe0 verror.IDAction
-pkg syncql, var ErrOperationNotSupported verror.IDAction
-pkg syncql, var ErrPreparedStatementNotFound verror.IDAction
-pkg syncql, var ErrScanError verror.IDAction
-pkg syncql, var ErrStringConversionError verror.IDAction
-pkg syncql, var ErrTableCantAccess verror.IDAction
-pkg syncql, var ErrTimeConversionError verror.IDAction
-pkg syncql, var ErrTooManyParamValuesSpecified verror.IDAction
-pkg syncql, var ErrUintConversionError verror.IDAction
-pkg syncql, var ErrUnexpected verror.IDAction
-pkg syncql, var ErrUnexpectedEndOfStatement verror.IDAction
-pkg syncql, var ErrUnknownIdentifier verror.IDAction
+pkg syncql, var ErrArgMustBeField unknown-type
+pkg syncql, var ErrBadFieldInWhere unknown-type
+pkg syncql, var ErrBigIntConversionError unknown-type
+pkg syncql, var ErrBigRatConversionError unknown-type
+pkg syncql, var ErrBoolConversionError unknown-type
+pkg syncql, var ErrBoolInvalidExpression unknown-type
+pkg syncql, var ErrCheckOfUnknownStatementType unknown-type
+pkg syncql, var ErrComplexConversionError unknown-type
+pkg syncql, var ErrCouldNotConvert unknown-type
+pkg syncql, var ErrDidYouMeanFunction unknown-type
+pkg syncql, var ErrDidYouMeanLowercaseK unknown-type
+pkg syncql, var ErrDidYouMeanLowercaseV unknown-type
+pkg syncql, var ErrDotNotationDisallowedForKey unknown-type
+pkg syncql, var ErrErrorCompilingRegularExpression unknown-type
+pkg syncql, var ErrExecOfUnknownStatementType unknown-type
+pkg syncql, var ErrExpected unknown-type
+pkg syncql, var ErrExpectedFrom unknown-type
+pkg syncql, var ErrExpectedIdentifier unknown-type
+pkg syncql, var ErrExpectedOperand unknown-type
+pkg syncql, var ErrExpectedOperator unknown-type
+pkg syncql, var ErrFloatConversionError unknown-type
+pkg syncql, var ErrFunctionArgBad unknown-type
+pkg syncql, var ErrFunctionArgCount unknown-type
+pkg syncql, var ErrFunctionAtLeastArgCount unknown-type
+pkg syncql, var ErrFunctionLenInvalidArg unknown-type
+pkg syncql, var ErrFunctionNotFound unknown-type
+pkg syncql, var ErrFunctionTypeInvalidArg unknown-type
+pkg syncql, var ErrIndexKindNotSupported unknown-type
+pkg syncql, var ErrIntConversionError unknown-type
+pkg syncql, var ErrInvalidEscapeChar unknown-type
+pkg syncql, var ErrInvalidEscapeSequence unknown-type
+pkg syncql, var ErrInvalidIndexField unknown-type
+pkg syncql, var ErrInvalidSelectField unknown-type
+pkg syncql, var ErrIsIsNotRequireLhsValue unknown-type
+pkg syncql, var ErrIsIsNotRequireRhsNil unknown-type
+pkg syncql, var ErrKeyExpressionLiteral unknown-type
+pkg syncql, var ErrKeyValueStreamError unknown-type
+pkg syncql, var ErrLikeExpressionsRequireRhsString unknown-type
+pkg syncql, var ErrLimitMustBeGt0 unknown-type
+pkg syncql, var ErrLocationConversionError unknown-type
+pkg syncql, var ErrMaxStatementLenExceeded unknown-type
+pkg syncql, var ErrNoStatementFound unknown-type
+pkg syncql, var ErrNotEnoughParamValuesSpecified unknown-type
+pkg syncql, var ErrNotWritable unknown-type
+pkg syncql, var ErrOffsetMustBeGe0 unknown-type
+pkg syncql, var ErrOperationNotSupported unknown-type
+pkg syncql, var ErrPreparedStatementNotFound unknown-type
+pkg syncql, var ErrScanError unknown-type
+pkg syncql, var ErrStringConversionError unknown-type
+pkg syncql, var ErrTableCantAccess unknown-type
+pkg syncql, var ErrTimeConversionError unknown-type
+pkg syncql, var ErrTooManyParamValuesSpecified unknown-type
+pkg syncql, var ErrUintConversionError unknown-type
+pkg syncql, var ErrUnexpected unknown-type
+pkg syncql, var ErrUnexpectedEndOfStatement unknown-type
+pkg syncql, var ErrUnknownIdentifier unknown-type
diff --git a/query/syncql/syncql.vdl.go b/query/syncql/syncql.vdl.go
index 9608197..1091109 100644
--- a/query/syncql/syncql.vdl.go
+++ b/query/syncql/syncql.vdl.go
@@ -375,6 +375,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Set error format strings.
i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrBadFieldInWhere.ID), "{1:}{2:} [{3}]Where field must be 'k' or 'v[{.<ident>}...]'.")
diff --git a/rpc/.api b/rpc/.api
index f8da1bb..989b974 100644
--- a/rpc/.api
+++ b/rpc/.api
@@ -19,12 +19,14 @@
pkg rpc, method (*Request) MakeVDLTarget() vdl.Target
pkg rpc, method (*RequestTarget) FinishField(vdl.Target, vdl.Target) error
pkg rpc, method (*RequestTarget) FinishFields(vdl.FieldsTarget) error
+pkg rpc, method (*RequestTarget) FromZero(*vdl.Type) error
pkg rpc, method (*RequestTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg rpc, method (*RequestTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg rpc, method (*Response) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg rpc, method (*Response) MakeVDLTarget() vdl.Target
pkg rpc, method (*ResponseTarget) FinishField(vdl.Target, vdl.Target) error
pkg rpc, method (*ResponseTarget) FinishFields(vdl.FieldsTarget) error
+pkg rpc, method (*ResponseTarget) FromZero(*vdl.Type) error
pkg rpc, method (*ResponseTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg rpc, method (*ResponseTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg rpc, method (AddressChooserFunc) ChooseAddresses(string, []net.Addr) ([]net.Addr, error)
diff --git a/rpc/reserved/.api b/rpc/reserved/.api
index d861fde..a38fe9c 100644
--- a/rpc/reserved/.api
+++ b/rpc/reserved/.api
@@ -3,6 +3,6 @@
pkg reserved, func NewErrGlobMaxRecursionReached(*context.T) error
pkg reserved, func NewErrGlobNotImplemented(*context.T) error
pkg reserved, func Signature(*context.T, string, ...rpc.CallOpt) ([]signature.Interface, error)
-pkg reserved, var ErrGlobMatchesOmitted verror.IDAction
-pkg reserved, var ErrGlobMaxRecursionReached verror.IDAction
-pkg reserved, var ErrGlobNotImplemented verror.IDAction
+pkg reserved, var ErrGlobMatchesOmitted unknown-type
+pkg reserved, var ErrGlobMaxRecursionReached unknown-type
+pkg reserved, var ErrGlobNotImplemented unknown-type
diff --git a/rpc/reserved/reserved.vdl.go b/rpc/reserved/reserved.vdl.go
index 5fb574e..6a59bc1 100644
--- a/rpc/reserved/reserved.vdl.go
+++ b/rpc/reserved/reserved.vdl.go
@@ -64,6 +64,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Set error format strings.
i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrGlobMaxRecursionReached.ID), "{1:}{2:} max recursion level reached{:_}")
diff --git a/rpc/rpc.vdl.go b/rpc/rpc.vdl.go
index 2347a4e..d5f8282 100644
--- a/rpc/rpc.vdl.go
+++ b/rpc/rpc.vdl.go
@@ -10,6 +10,7 @@
import (
"fmt"
"v.io/v23/security"
+ "v.io/v23/uniqueid"
"v.io/v23/vdl"
"v.io/v23/vdlroot/time"
"v.io/v23/verror"
@@ -69,113 +70,181 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Suffix")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Suffix), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Suffix == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Suffix), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Method")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Method")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Method), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Method == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Method), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("NumPosArgs")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("NumPosArgs")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromUint(uint64(m.NumPosArgs), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("EndStreamArgs")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget9.FromBool(bool(m.EndStreamArgs), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var10 := (m.NumPosArgs == uint64(0))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromUint(uint64(m.NumPosArgs), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- var wireValue10 time.WireDeadline
- if err := time.WireDeadlineFromNative(&wireValue10, m.Deadline); err != nil {
- return err
- }
-
- keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Deadline")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("EndStreamArgs")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue10.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(4).Type); err != nil {
- return err
+ var13 := (m.EndStreamArgs == false)
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget12.FromBool(bool(m.EndStreamArgs), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
- var wireValue13 security.WireBlessings
- if err := security.WireBlessingsFromNative(&wireValue13, m.GrantedBlessings); err != nil {
+ var wireValue14 time.WireDeadline
+ if err := time.WireDeadlineFromNative(&wireValue14, m.Deadline); err != nil {
return err
}
- keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("GrantedBlessings")
+ keyTarget15, fieldTarget16, err := fieldsTarget1.StartField("Deadline")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue13.FillVDLTarget(fieldTarget15, tt.NonOptional().Field(5).Type); err != nil {
- return err
+ var17 := (wireValue14 == time.WireDeadline{})
+ if var17 {
+ if err := fieldTarget16.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue14.FillVDLTarget(fieldTarget16, tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget15, fieldTarget16); err != nil {
return err
}
}
- keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("TraceRequest")
+ var wireValue18 security.WireBlessings
+ if err := security.WireBlessingsFromNative(&wireValue18, m.GrantedBlessings); err != nil {
+ return err
+ }
+
+ keyTarget19, fieldTarget20, err := fieldsTarget1.StartField("GrantedBlessings")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.TraceRequest.FillVDLTarget(fieldTarget17, tt.NonOptional().Field(6).Type); err != nil {
- return err
+ var21 := true
+ var var22 bool
+ if len(wireValue18.CertificateChains) == 0 {
+ var22 = true
}
- if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
+ var21 = var21 && var22
+ if var21 {
+ if err := fieldTarget20.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue18.FillVDLTarget(fieldTarget20, tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget19, fieldTarget20); err != nil {
return err
}
}
- keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("Language")
+ keyTarget23, fieldTarget24, err := fieldsTarget1.StartField("TraceRequest")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget19.FromString(string(m.Language), tt.NonOptional().Field(7).Type); err != nil {
+
+ var25 := (m.TraceRequest == vtrace.Request{})
+ if var25 {
+ if err := fieldTarget24.FromZero(tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.TraceRequest.FillVDLTarget(fieldTarget24, tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget23, fieldTarget24); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil {
+ }
+ keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("Language")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var28 := (m.Language == "")
+ if var28 {
+ if err := fieldTarget27.FromZero(tt.NonOptional().Field(7).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget27.FromString(string(m.Language), tt.NonOptional().Field(7).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
return err
}
}
@@ -255,6 +324,10 @@
return nil
}
+func (t *RequestTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Request{}
+ return nil
+}
// Response describes the response header sent by the server to the client. A
// zero response header is sent before each streaming arg. Thereafter a
@@ -288,23 +361,24 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Error")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.Error == nil {
- if err := fieldTarget3.FromNil(tt.NonOptional().Field(0).Type); err != nil {
+ var4 := (m.Error == (error)(nil))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
return err
}
} else {
- var wireError4 vdl.WireError
- if err := verror.WireFromNative(&wireError4, m.Error); err != nil {
+
+ var wireError5 vdl.WireError
+ if err := verror.WireFromNative(&wireError5, m.Error); err != nil {
return err
}
- if err := wireError4.FillVDLTarget(fieldTarget3, vdl.ErrorType); err != nil {
+ if err := wireError5.FillVDLTarget(fieldTarget3, vdl.ErrorType); err != nil {
return err
}
@@ -313,52 +387,95 @@
return err
}
}
- keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("EndStreamResults")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget6.FromBool(bool(m.EndStreamResults), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
- return err
- }
- }
- keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("NumPosResults")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget8.FromUint(uint64(m.NumPosResults), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
- return err
- }
- }
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("TraceResponse")
+ keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("EndStreamResults")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.TraceResponse.FillVDLTarget(fieldTarget10, tt.NonOptional().Field(3).Type); err != nil {
+ var8 := (m.EndStreamResults == false)
+ if var8 {
+ if err := fieldTarget7.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget7.FromBool(bool(m.EndStreamResults), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
return err
}
+ }
+ keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("NumPosResults")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var11 := (m.NumPosResults == uint64(0))
+ if var11 {
+ if err := fieldTarget10.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget10.FromUint(uint64(m.NumPosResults), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
return err
}
}
- keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("AckBlessings")
+ keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("TraceResponse")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget12.FromBool(bool(m.AckBlessings), tt.NonOptional().Field(4).Type); err != nil {
+
+ var14 := true
+ var15 := (m.TraceResponse.Flags == vtrace.TraceFlags(0))
+ var14 = var14 && var15
+ var16 := true
+ var17 := (m.TraceResponse.Trace.Id == uniqueid.Id{})
+ var16 = var16 && var17
+ var var18 bool
+ if len(m.TraceResponse.Trace.Spans) == 0 {
+ var18 = true
+ }
+ var16 = var16 && var18
+ var14 = var14 && var16
+ if var14 {
+ if err := fieldTarget13.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.TraceResponse.FillVDLTarget(fieldTarget13, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ }
+ keyTarget19, fieldTarget20, err := fieldsTarget1.StartField("AckBlessings")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var21 := (m.AckBlessings == false)
+ if var21 {
+ if err := fieldTarget20.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget20.FromBool(bool(m.AckBlessings), tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget19, fieldTarget20); err != nil {
return err
}
}
@@ -423,12 +540,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroRequest = Request{}
- __VDLZeroResponse = Response{}
-)
+func (t *ResponseTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Response{}
+ return nil
+}
//////////////////////////////////////////////////
// Const definitions
@@ -457,6 +572,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*Request)(nil))
diff --git a/rpc/version/.api b/rpc/version/.api
index 836c50c..db2c98a 100644
--- a/rpc/version/.api
+++ b/rpc/version/.api
@@ -11,4 +11,4 @@
pkg version, type RPCVersionRange struct
pkg version, type RPCVersionRange struct, Max RPCVersion
pkg version, type RPCVersionRange struct, Min RPCVersion
-pkg version, var ErrNoCompatibleVersion verror.IDAction
+pkg version, var ErrNoCompatibleVersion unknown-type
diff --git a/rpc/version/version.vdl.go b/rpc/version/version.vdl.go
index 190a039..dbaa677 100644
--- a/rpc/version/version.vdl.go
+++ b/rpc/version/version.vdl.go
@@ -45,6 +45,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Set error format strings.
i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrNoCompatibleVersion.ID), "{1:}{2:} There were no compatible versions between ({3},{4}) and ({5},{6}).")
diff --git a/security/.api b/security/.api
index c45a321..562bc1f 100644
--- a/security/.api
+++ b/security/.api
@@ -58,6 +58,7 @@
pkg security, method (*BlessingPattern) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg security, method (*BlessingPattern) MakeVDLTarget() vdl.Target
pkg security, method (*BlessingPatternTarget) FromString(string, *vdl.Type) error
+pkg security, method (*BlessingPatternTarget) FromZero(*vdl.Type) error
pkg security, method (*CallParams) Copy(Call)
pkg security, method (*Caveat) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg security, method (*Caveat) MakeVDLTarget() vdl.Target
@@ -67,31 +68,37 @@
pkg security, method (*CaveatDescriptor) MakeVDLTarget() vdl.Target
pkg security, method (*CaveatDescriptorTarget) FinishField(vdl.Target, vdl.Target) error
pkg security, method (*CaveatDescriptorTarget) FinishFields(vdl.FieldsTarget) error
+pkg security, method (*CaveatDescriptorTarget) FromZero(*vdl.Type) error
pkg security, method (*CaveatDescriptorTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg security, method (*CaveatDescriptorTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg security, method (*CaveatTarget) FinishField(vdl.Target, vdl.Target) error
pkg security, method (*CaveatTarget) FinishFields(vdl.FieldsTarget) error
+pkg security, method (*CaveatTarget) FromZero(*vdl.Type) error
pkg security, method (*CaveatTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg security, method (*CaveatTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg security, method (*Certificate) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg security, method (*Certificate) MakeVDLTarget() vdl.Target
pkg security, method (*CertificateTarget) FinishField(vdl.Target, vdl.Target) error
pkg security, method (*CertificateTarget) FinishFields(vdl.FieldsTarget) error
+pkg security, method (*CertificateTarget) FromZero(*vdl.Type) error
pkg security, method (*CertificateTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg security, method (*CertificateTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg security, method (*DischargeImpetus) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg security, method (*DischargeImpetus) MakeVDLTarget() vdl.Target
pkg security, method (*DischargeImpetusTarget) FinishField(vdl.Target, vdl.Target) error
pkg security, method (*DischargeImpetusTarget) FinishFields(vdl.FieldsTarget) error
+pkg security, method (*DischargeImpetusTarget) FromZero(*vdl.Type) error
pkg security, method (*DischargeImpetusTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg security, method (*DischargeImpetusTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg security, method (*Hash) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg security, method (*Hash) MakeVDLTarget() vdl.Target
pkg security, method (*HashTarget) FromString(string, *vdl.Type) error
+pkg security, method (*HashTarget) FromZero(*vdl.Type) error
pkg security, method (*RejectedBlessing) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg security, method (*RejectedBlessing) MakeVDLTarget() vdl.Target
pkg security, method (*RejectedBlessingTarget) FinishField(vdl.Target, vdl.Target) error
pkg security, method (*RejectedBlessingTarget) FinishFields(vdl.FieldsTarget) error
+pkg security, method (*RejectedBlessingTarget) FromZero(*vdl.Type) error
pkg security, method (*RejectedBlessingTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg security, method (*RejectedBlessingTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg security, method (*Signature) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -99,22 +106,26 @@
pkg security, method (*Signature) Verify(PublicKey, []byte) bool
pkg security, method (*SignatureTarget) FinishField(vdl.Target, vdl.Target) error
pkg security, method (*SignatureTarget) FinishFields(vdl.FieldsTarget) error
+pkg security, method (*SignatureTarget) FromZero(*vdl.Type) error
pkg security, method (*SignatureTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg security, method (*SignatureTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg security, method (*ThirdPartyRequirements) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg security, method (*ThirdPartyRequirements) MakeVDLTarget() vdl.Target
pkg security, method (*ThirdPartyRequirementsTarget) FinishField(vdl.Target, vdl.Target) error
pkg security, method (*ThirdPartyRequirementsTarget) FinishFields(vdl.FieldsTarget) error
+pkg security, method (*ThirdPartyRequirementsTarget) FromZero(*vdl.Type) error
pkg security, method (*ThirdPartyRequirementsTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg security, method (*ThirdPartyRequirementsTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg security, method (*WireBlessings) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg security, method (*WireBlessings) MakeVDLTarget() vdl.Target
pkg security, method (*WireBlessingsTarget) FinishField(vdl.Target, vdl.Target) error
pkg security, method (*WireBlessingsTarget) FinishFields(vdl.FieldsTarget) error
+pkg security, method (*WireBlessingsTarget) FromZero(*vdl.Type) error
pkg security, method (*WireBlessingsTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg security, method (*WireBlessingsTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg security, method (*WireDischargeTarget) FinishField(vdl.Target, vdl.Target) error
pkg security, method (*WireDischargeTarget) FinishFields(vdl.FieldsTarget) error
+pkg security, method (*WireDischargeTarget) FromZero(*vdl.Type) error
pkg security, method (*WireDischargeTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg security, method (*WireDischargeTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg security, method (BlessingPattern) IsValid() bool
@@ -284,20 +295,20 @@
pkg security, type WireDischargeTarget struct, embedded vdl.FieldsTargetBase
pkg security, type WireDischargeTarget struct, embedded vdl.TargetBase
pkg security, var ConstCaveat CaveatDescriptor
-pkg security, var ErrAuthorizationFailed verror.IDAction
-pkg security, var ErrCaveatNotRegistered verror.IDAction
-pkg security, var ErrCaveatParamAny verror.IDAction
-pkg security, var ErrCaveatParamCoding verror.IDAction
-pkg security, var ErrCaveatParamTypeMismatch verror.IDAction
-pkg security, var ErrCaveatValidation verror.IDAction
-pkg security, var ErrConstCaveatValidation verror.IDAction
-pkg security, var ErrEndpointAuthorizationFailed verror.IDAction
-pkg security, var ErrExpiryCaveatValidation verror.IDAction
-pkg security, var ErrInvalidSigningBlessingCaveat verror.IDAction
-pkg security, var ErrMethodCaveatValidation verror.IDAction
-pkg security, var ErrPeerBlessingsCaveatValidation verror.IDAction
-pkg security, var ErrPublicKeyNotAllowed verror.IDAction
-pkg security, var ErrUnrecognizedRoot verror.IDAction
+pkg security, var ErrAuthorizationFailed unknown-type
+pkg security, var ErrCaveatNotRegistered unknown-type
+pkg security, var ErrCaveatParamAny unknown-type
+pkg security, var ErrCaveatParamCoding unknown-type
+pkg security, var ErrCaveatParamTypeMismatch unknown-type
+pkg security, var ErrCaveatValidation unknown-type
+pkg security, var ErrConstCaveatValidation unknown-type
+pkg security, var ErrEndpointAuthorizationFailed unknown-type
+pkg security, var ErrExpiryCaveatValidation unknown-type
+pkg security, var ErrInvalidSigningBlessingCaveat unknown-type
+pkg security, var ErrMethodCaveatValidation unknown-type
+pkg security, var ErrPeerBlessingsCaveatValidation unknown-type
+pkg security, var ErrPublicKeyNotAllowed unknown-type
+pkg security, var ErrUnrecognizedRoot unknown-type
pkg security, var ExpiryCaveat CaveatDescriptor
pkg security, var MethodCaveat CaveatDescriptor
pkg security, var PeerBlessingsCaveat CaveatDescriptor
diff --git a/security/access/.api b/security/access/.api
index bbd3383..2c94cf3 100644
--- a/security/access/.api
+++ b/security/access/.api
@@ -22,6 +22,7 @@
pkg access, method (*AccessList) MakeVDLTarget() vdl.Target
pkg access, method (*AccessListTarget) FinishField(vdl.Target, vdl.Target) error
pkg access, method (*AccessListTarget) FinishFields(vdl.FieldsTarget) error
+pkg access, method (*AccessListTarget) FromZero(*vdl.Type) error
pkg access, method (*AccessListTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg access, method (*AccessListTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg access, method (*Permissions) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -29,11 +30,13 @@
pkg access, method (*PermissionsTarget) FinishField(vdl.Target, vdl.Target) error
pkg access, method (*PermissionsTarget) FinishKeyStartField(vdl.Target) (vdl.Target, error)
pkg access, method (*PermissionsTarget) FinishMap(vdl.MapTarget) error
+pkg access, method (*PermissionsTarget) FromZero(*vdl.Type) error
pkg access, method (*PermissionsTarget) StartKey() (vdl.Target, error)
pkg access, method (*PermissionsTarget) StartMap(*vdl.Type, int) (vdl.MapTarget, error)
pkg access, method (*Tag) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg access, method (*Tag) MakeVDLTarget() vdl.Target
pkg access, method (*TagTarget) FromString(string, *vdl.Type) error
+pkg access, method (*TagTarget) FromZero(*vdl.Type) error
pkg access, method (AccessList) Authorize(*context.T, security.Call) error
pkg access, method (AccessList) Enforceable(*context.T, security.Principal) error
pkg access, method (AccessList) Includes(...string) bool
@@ -59,9 +62,9 @@
pkg access, type TagTarget struct, Value *Tag
pkg access, type TagTarget struct, embedded vdl.TargetBase
pkg access, var AccessTagCaveat security.CaveatDescriptor
-pkg access, var ErrAccessListMatch verror.IDAction
-pkg access, var ErrAccessTagCaveatValidation verror.IDAction
-pkg access, var ErrInvalidOpenAccessList verror.IDAction
-pkg access, var ErrNoPermissions verror.IDAction
-pkg access, var ErrTooBig verror.IDAction
-pkg access, var ErrUnenforceablePatterns verror.IDAction
+pkg access, var ErrAccessListMatch unknown-type
+pkg access, var ErrAccessTagCaveatValidation unknown-type
+pkg access, var ErrInvalidOpenAccessList unknown-type
+pkg access, var ErrNoPermissions unknown-type
+pkg access, var ErrTooBig unknown-type
+pkg access, var ErrUnenforceablePatterns unknown-type
diff --git a/security/access/access.vdl.go b/security/access/access.vdl.go
index b4cd6ea..c719e9c 100644
--- a/security/access/access.vdl.go
+++ b/security/access/access.vdl.go
@@ -151,63 +151,84 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("In")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget4, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.In))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.In) == 0 {
+ var4 = true
}
- for i, elem6 := range m.In {
- elemTarget5, err := listTarget4.StartElem(i)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget5, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.In))
if err != nil {
return err
}
+ for i, elem7 := range m.In {
+ elemTarget6, err := listTarget5.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem6.FillVDLTarget(elemTarget5, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ if err := elem7.FillVDLTarget(elemTarget6, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget5.FinishElem(elemTarget6); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishList(listTarget5); err != nil {
return err
}
- if err := listTarget4.FinishElem(elemTarget5); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishList(listTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("NotIn")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("NotIn")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget9, err := fieldTarget8.StartList(tt.NonOptional().Field(1).Type, len(m.NotIn))
- if err != nil {
- return err
+ var var10 bool
+ if len(m.NotIn) == 0 {
+ var10 = true
}
- for i, elem11 := range m.NotIn {
- elemTarget10, err := listTarget9.StartElem(i)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget11, err := fieldTarget9.StartList(tt.NonOptional().Field(1).Type, len(m.NotIn))
if err != nil {
return err
}
- if err := elemTarget10.FromString(string(elem11), tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ for i, elem13 := range m.NotIn {
+ elemTarget12, err := listTarget11.StartElem(i)
+ if err != nil {
+ return err
+ }
+ if err := elemTarget12.FromString(string(elem13), tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget11.FinishElem(elemTarget12); err != nil {
+ return err
+ }
}
- if err := listTarget9.FinishElem(elemTarget10); err != nil {
+ if err := fieldTarget9.FinishList(listTarget11); err != nil {
return err
}
}
- if err := fieldTarget8.FinishList(listTarget9); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -257,6 +278,10 @@
return nil
}
+func (t *AccessListTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = AccessList{}
+ return nil
+}
// []security.BlessingPattern
type __VDLTarget1_list struct {
@@ -290,6 +315,10 @@
return nil
}
+func (t *__VDLTarget1_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []security.BlessingPattern(nil)
+ return nil
+}
// Permissions maps string tags to access lists specifying the blessings
// required to invoke methods with that tag.
@@ -381,6 +410,10 @@
return nil
}
+func (t *PermissionsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Permissions(nil)
+ return nil
+}
// Tag is used to associate methods with an AccessList in a Permissions.
//
@@ -419,13 +452,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroAccessList = AccessList{}
- __VDLZeroPermissions = Permissions(nil)
- __VDLZeroTag = Tag("")
-)
+func (t *TagTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Tag("")
+ return nil
+}
//////////////////////////////////////////////////
// Const definitions
@@ -521,6 +551,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*AccessList)(nil))
diff --git a/security/access/internal/internal.vdl.go b/security/access/internal/internal.vdl.go
index 5f1e217..d3d2661 100644
--- a/security/access/internal/internal.vdl.go
+++ b/security/access/internal/internal.vdl.go
@@ -56,11 +56,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroMyTag = MyTag("")
-)
+func (t *MyTagTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MyTag("")
+ return nil
+}
//////////////////////////////////////////////////
// Const definitions
@@ -236,6 +235,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*MyTag)(nil))
diff --git a/security/security.vdl.go b/security/security.vdl.go
index 3a61113..071811d 100644
--- a/security/security.vdl.go
+++ b/security/security.vdl.go
@@ -57,6 +57,10 @@
return nil
}
+func (t *nonceTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = nonce{}
+ return nil
+}
// Caveat is a condition on the validity of a blessing/discharge.
//
@@ -81,30 +85,48 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Id")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Id.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Id == uniqueid.Id{})
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Id.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("ParamVom")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("ParamVom")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromBytes([]byte(m.ParamVom), tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var var7 bool
+ if len(m.ParamVom) == 0 {
+ var7 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget6.FromBytes([]byte(m.ParamVom), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -154,6 +176,10 @@
return nil
}
+func (t *CaveatTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Caveat{}
+ return nil
+}
// ThirdPartyRequirements specifies the information required by the third-party
// that will issue discharges for third-party caveats.
@@ -176,40 +202,63 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("ReportServer")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromBool(bool(m.ReportServer), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.ReportServer == false)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromBool(bool(m.ReportServer), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("ReportMethod")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("ReportMethod")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromBool(bool(m.ReportMethod), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.ReportMethod == false)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromBool(bool(m.ReportMethod), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("ReportArguments")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("ReportArguments")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromBool(bool(m.ReportArguments), tt.NonOptional().Field(2).Type); err != nil {
- return err
+
+ var10 := (m.ReportArguments == false)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromBool(bool(m.ReportArguments), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -264,6 +313,10 @@
return nil
}
+func (t *ThirdPartyRequirementsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ThirdPartyRequirements{}
+ return nil
+}
// publicKeyThirdPartyCaveatParam represents a third-party caveat that requires
// discharges to be issued by a principal identified by a public key.
@@ -305,85 +358,130 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Nonce")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Nonce.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Nonce == nonce{})
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Nonce.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Caveats")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Caveats")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget6, err := fieldTarget5.StartList(tt.NonOptional().Field(1).Type, len(m.Caveats))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.Caveats) == 0 {
+ var7 = true
}
- for i, elem8 := range m.Caveats {
- elemTarget7, err := listTarget6.StartElem(i)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.Caveats))
if err != nil {
return err
}
+ for i, elem10 := range m.Caveats {
+ elemTarget9, err := listTarget8.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem8.FillVDLTarget(elemTarget7, tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ return err
+ }
}
- if err := listTarget6.FinishElem(elemTarget7); err != nil {
+ if err := fieldTarget6.FinishList(listTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishList(listTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("DischargerKey")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("DischargerKey")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget10.FromBytes([]byte(m.DischargerKey), tt.NonOptional().Field(2).Type); err != nil {
- return err
+ var var13 bool
+ if len(m.DischargerKey) == 0 {
+ var13 = true
}
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
- return err
- }
- }
- keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("DischargerLocation")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget12.FromString(string(m.DischargerLocation), tt.NonOptional().Field(3).Type); err != nil {
- return err
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget12.FromBytes([]byte(m.DischargerKey), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
- keyTarget13, fieldTarget14, err := fieldsTarget1.StartField("DischargerRequirements")
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("DischargerLocation")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.DischargerRequirements.FillVDLTarget(fieldTarget14, tt.NonOptional().Field(4).Type); err != nil {
+ var16 := (m.DischargerLocation == "")
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget15.FromString(string(m.DischargerLocation), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget13, fieldTarget14); err != nil {
+ }
+ keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("DischargerRequirements")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var19 := (m.DischargerRequirements == ThirdPartyRequirements{})
+ if var19 {
+ if err := fieldTarget18.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.DischargerRequirements.FillVDLTarget(fieldTarget18, tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
return err
}
}
@@ -448,6 +546,10 @@
return nil
}
+func (t *publicKeyThirdPartyCaveatParamTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = publicKeyThirdPartyCaveatParam{}
+ return nil
+}
// []Caveat
type __VDLTarget1_list struct {
@@ -481,6 +583,10 @@
return nil
}
+func (t *__VDLTarget1_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []Caveat(nil)
+ return nil
+}
// Hash identifies a cryptographic hash function approved for use in signature algorithms.
type Hash string
@@ -515,6 +621,10 @@
return nil
}
+func (t *HashTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Hash("")
+ return nil
+}
// Signature represents a digital signature.
type Signature struct {
@@ -539,59 +649,99 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Purpose")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromBytes([]byte(m.Purpose), tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var var4 bool
+ if len(m.Purpose) == 0 {
+ var4 = true
+ }
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget3.FromBytes([]byte(m.Purpose), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Hash")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Hash")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Hash.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.Hash == Hash(""))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Hash.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("R")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("R")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromBytes([]byte(m.R), tt.NonOptional().Field(2).Type); err != nil {
- return err
+ var var10 bool
+ if len(m.R) == 0 {
+ var10 = true
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("S")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
- if err := fieldTarget9.FromBytes([]byte(m.S), tt.NonOptional().Field(3).Type); err != nil {
- return err
+ if err := fieldTarget9.FromBytes([]byte(m.R), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("S")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var13 bool
+ if len(m.S) == 0 {
+ var13 = true
+ }
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget12.FromBytes([]byte(m.S), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -648,6 +798,10 @@
return nil
}
+func (t *SignatureTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Signature{}
+ return nil
+}
// publicKeyDischarge represents the discharge issued for publicKeyThirdPartyCaveatParams.
//
@@ -671,59 +825,102 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("ThirdPartyCaveatId")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.ThirdPartyCaveatId), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.ThirdPartyCaveatId == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.ThirdPartyCaveatId), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Caveats")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Caveats")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget6, err := fieldTarget5.StartList(tt.NonOptional().Field(1).Type, len(m.Caveats))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.Caveats) == 0 {
+ var7 = true
}
- for i, elem8 := range m.Caveats {
- elemTarget7, err := listTarget6.StartElem(i)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.Caveats))
if err != nil {
return err
}
+ for i, elem10 := range m.Caveats {
+ elemTarget9, err := listTarget8.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem8.FillVDLTarget(elemTarget7, tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ return err
+ }
}
- if err := listTarget6.FinishElem(elemTarget7); err != nil {
+ if err := fieldTarget6.FinishList(listTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishList(listTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Signature")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Signature")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Signature.FillVDLTarget(fieldTarget10, tt.NonOptional().Field(2).Type); err != nil {
- return err
+ var13 := true
+ var var14 bool
+ if len(m.Signature.Purpose) == 0 {
+ var14 = true
}
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
+ var13 = var13 && var14
+ var15 := (m.Signature.Hash == Hash(""))
+ var13 = var13 && var15
+ var var16 bool
+ if len(m.Signature.R) == 0 {
+ var16 = true
+ }
+ var13 = var13 && var16
+ var var17 bool
+ if len(m.Signature.S) == 0 {
+ var17 = true
+ }
+ var13 = var13 && var17
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Signature.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
@@ -778,6 +975,10 @@
return nil
}
+func (t *publicKeyDischargeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = publicKeyDischarge{}
+ return nil
+}
// BlessingPattern is a pattern that is matched by specific blessings.
//
@@ -824,6 +1025,10 @@
return nil
}
+func (t *BlessingPatternTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BlessingPattern("")
+ return nil
+}
// DischargeImpetus encapsulates the motivation for a discharge being sought.
//
@@ -851,82 +1056,111 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Server")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget4, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.Server))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.Server) == 0 {
+ var4 = true
}
- for i, elem6 := range m.Server {
- elemTarget5, err := listTarget4.StartElem(i)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget5, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.Server))
if err != nil {
return err
}
+ for i, elem7 := range m.Server {
+ elemTarget6, err := listTarget5.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem6.FillVDLTarget(elemTarget5, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ if err := elem7.FillVDLTarget(elemTarget6, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget5.FinishElem(elemTarget6); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishList(listTarget5); err != nil {
return err
}
- if err := listTarget4.FinishElem(elemTarget5); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishList(listTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("Method")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget8.FromString(string(m.Method), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
- return err
- }
- }
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Arguments")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Method")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget11, err := fieldTarget10.StartList(tt.NonOptional().Field(2).Type, len(m.Arguments))
- if err != nil {
+ var10 := (m.Method == "")
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromString(string(m.Method), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
- for i, elem13 := range m.Arguments {
- elemTarget12, err := listTarget11.StartElem(i)
+ }
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Arguments")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var13 bool
+ if len(m.Arguments) == 0 {
+ var13 = true
+ }
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget14, err := fieldTarget12.StartList(tt.NonOptional().Field(2).Type, len(m.Arguments))
if err != nil {
return err
}
-
- if elem13 == nil {
- if err := elemTarget12.FromNil(tt.NonOptional().Field(2).Type.Elem()); err != nil {
+ for i, elem16 := range m.Arguments {
+ elemTarget15, err := listTarget14.StartElem(i)
+ if err != nil {
return err
}
- } else {
- if err := elem13.FillVDLTarget(elemTarget12, tt.NonOptional().Field(2).Type.Elem()); err != nil {
+
+ if elem16 == nil {
+ if err := elemTarget15.FromZero(tt.NonOptional().Field(2).Type.Elem()); err != nil {
+ return err
+ }
+ } else {
+ if err := elem16.FillVDLTarget(elemTarget15, tt.NonOptional().Field(2).Type.Elem()); err != nil {
+ return err
+ }
+ }
+ if err := listTarget14.FinishElem(elemTarget15); err != nil {
return err
}
}
- if err := listTarget11.FinishElem(elemTarget12); err != nil {
+ if err := fieldTarget12.FinishList(listTarget14); err != nil {
return err
}
}
- if err := fieldTarget10.FinishList(listTarget11); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
@@ -981,6 +1215,10 @@
return nil
}
+func (t *DischargeImpetusTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = DischargeImpetus{}
+ return nil
+}
// []BlessingPattern
type __VDLTarget2_list struct {
@@ -1014,6 +1252,10 @@
return nil
}
+func (t *__VDLTarget2_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []BlessingPattern(nil)
+ return nil
+}
// []*vom.RawBytes
type __VDLTarget3_list struct {
@@ -1046,6 +1288,10 @@
return nil
}
+func (t *__VDLTarget3_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []*vom.RawBytes(nil)
+ return nil
+}
// Certificate represents the cryptographic proof of the binding of
// extensions of a blessing held by one principal to another (represented by
@@ -1071,72 +1317,126 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Extension")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Extension), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Extension == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Extension), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("PublicKey")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("PublicKey")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromBytes([]byte(m.PublicKey), tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var var7 bool
+ if len(m.PublicKey) == 0 {
+ var7 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget6.FromBytes([]byte(m.PublicKey), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Caveats")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Caveats")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget8, err := fieldTarget7.StartList(tt.NonOptional().Field(2).Type, len(m.Caveats))
- if err != nil {
- return err
+ var var10 bool
+ if len(m.Caveats) == 0 {
+ var10 = true
}
- for i, elem10 := range m.Caveats {
- elemTarget9, err := listTarget8.StartElem(i)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget11, err := fieldTarget9.StartList(tt.NonOptional().Field(2).Type, len(m.Caveats))
if err != nil {
return err
}
+ for i, elem13 := range m.Caveats {
+ elemTarget12, err := listTarget11.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(2).Type.Elem()); err != nil {
- return err
+ if err := elem13.FillVDLTarget(elemTarget12, tt.NonOptional().Field(2).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget11.FinishElem(elemTarget12); err != nil {
+ return err
+ }
}
- if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ if err := fieldTarget9.FinishList(listTarget11); err != nil {
return err
}
}
- if err := fieldTarget7.FinishList(listTarget8); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Signature")
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Signature")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Signature.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
- return err
+ var16 := true
+ var var17 bool
+ if len(m.Signature.Purpose) == 0 {
+ var17 = true
}
- if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ var16 = var16 && var17
+ var18 := (m.Signature.Hash == Hash(""))
+ var16 = var16 && var18
+ var var19 bool
+ if len(m.Signature.R) == 0 {
+ var19 = true
+ }
+ var16 = var16 && var19
+ var var20 bool
+ if len(m.Signature.S) == 0 {
+ var20 = true
+ }
+ var16 = var16 && var20
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Signature.FillVDLTarget(fieldTarget15, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
@@ -1196,6 +1496,10 @@
return nil
}
+func (t *CertificateTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Certificate{}
+ return nil
+}
// CaveatDescriptor defines an association between a caveat validation function
// (addressed by globally unique identifier) and the data needed by the
@@ -1218,33 +1522,48 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Id")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Id.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Id == uniqueid.Id{})
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Id.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("ParamType")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("ParamType")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- typeObjectVal6 := m.ParamType
- if typeObjectVal6 == nil {
- typeObjectVal6 = vdl.AnyType
+
+ var7 := (m.ParamType == vdl.AnyType)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ typeObjectVal8 := m.ParamType
+ if typeObjectVal8 == nil {
+ typeObjectVal8 = vdl.AnyType
+ }
+ if err := fieldTarget6.FromTypeObject(typeObjectVal8); err != nil {
+ return err
+ }
}
- if err := fieldTarget5.FromTypeObject(typeObjectVal6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1294,6 +1613,12 @@
return nil
}
+func (t *CaveatDescriptorTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = CaveatDescriptor{
+ ParamType: vdl.AnyType,
+ }
+ return nil
+}
// WireBlessings encapsulates wire format of a set of blessings and the
// corresponding cryptographic proof that binds them to a principal
@@ -1319,49 +1644,59 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("CertificateChains")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget4, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.CertificateChains))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.CertificateChains) == 0 {
+ var4 = true
}
- for i, elem6 := range m.CertificateChains {
- elemTarget5, err := listTarget4.StartElem(i)
- if err != nil {
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
return err
}
+ } else {
- listTarget7, err := elemTarget5.StartList(tt.NonOptional().Field(0).Type.Elem(), len(elem6))
+ listTarget5, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.CertificateChains))
if err != nil {
return err
}
- for i, elem9 := range elem6 {
- elemTarget8, err := listTarget7.StartElem(i)
+ for i, elem7 := range m.CertificateChains {
+ elemTarget6, err := listTarget5.StartElem(i)
if err != nil {
return err
}
- if err := elem9.FillVDLTarget(elemTarget8, tt.NonOptional().Field(0).Type.Elem().Elem()); err != nil {
+ listTarget8, err := elemTarget6.StartList(tt.NonOptional().Field(0).Type.Elem(), len(elem7))
+ if err != nil {
return err
}
- if err := listTarget7.FinishElem(elemTarget8); err != nil {
+ for i, elem10 := range elem7 {
+ elemTarget9, err := listTarget8.StartElem(i)
+ if err != nil {
+ return err
+ }
+
+ if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(0).Type.Elem().Elem()); err != nil {
+ return err
+ }
+ if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ return err
+ }
+ }
+ if err := elemTarget6.FinishList(listTarget8); err != nil {
+ return err
+ }
+ if err := listTarget5.FinishElem(elemTarget6); err != nil {
return err
}
}
- if err := elemTarget5.FinishList(listTarget7); err != nil {
+ if err := fieldTarget3.FinishList(listTarget5); err != nil {
return err
}
- if err := listTarget4.FinishElem(elemTarget5); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishList(listTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -1412,6 +1747,16 @@
}
return nil
}
+func (t *WireBlessingsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = func() Blessings {
+ var native Blessings
+ if err := vdl.Convert(&native, WireBlessings{}); err != nil {
+ panic(err)
+ }
+ return native
+ }()
+ return nil
+}
// [][]Certificate
type __VDLTarget4_list struct {
@@ -1445,6 +1790,10 @@
return nil
}
+func (t *__VDLTarget4_list) FromZero(tt *vdl.Type) error {
+ *t.Value = [][]Certificate(nil)
+ return nil
+}
// []Certificate
type __VDLTarget5_list struct {
@@ -1478,6 +1827,10 @@
return nil
}
+func (t *__VDLTarget5_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []Certificate(nil)
+ return nil
+}
type (
// WireDischarge represents any single field of the WireDischarge union type.
@@ -1580,6 +1933,16 @@
}
return nil
}
+func (t *WireDischargeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = func() Discharge {
+ var native Discharge
+ if err := vdl.Convert(&native, WireDischarge(WireDischargePublicKey{})); err != nil {
+ panic(err)
+ }
+ return native
+ }()
+ return nil
+}
type wireDischargeTargetFactory struct{}
@@ -1606,40 +1969,49 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Blessing")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Blessing), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Blessing == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Blessing), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Err")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Err")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.Err == nil {
- if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
+ var7 := (m.Err == (error)(nil))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- var wireError6 vdl.WireError
- if err := verror.WireFromNative(&wireError6, m.Err); err != nil {
+
+ var wireError8 vdl.WireError
+ if err := verror.WireFromNative(&wireError8, m.Err); err != nil {
return err
}
- if err := wireError6.FillVDLTarget(fieldTarget5, vdl.ErrorType); err != nil {
+ if err := wireError8.FillVDLTarget(fieldTarget6, vdl.ErrorType); err != nil {
return err
}
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1689,38 +2061,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZerononce = nonce{}
- __VDLZeroCaveat = Caveat{}
- __VDLZeroThirdPartyRequirements = ThirdPartyRequirements{}
- __VDLZeropublicKeyThirdPartyCaveatParam = publicKeyThirdPartyCaveatParam{}
- __VDLZeroHash = Hash("")
- __VDLZeroSignature = Signature{}
- __VDLZeropublicKeyDischarge = publicKeyDischarge{}
- __VDLZeroBlessingPattern = BlessingPattern("")
- __VDLZeroDischargeImpetus = DischargeImpetus{}
- __VDLZeroCertificate = Certificate{}
- __VDLZeroCaveatDescriptor = CaveatDescriptor{
- ParamType: vdl.AnyType,
- }
- __VDLZeroWireBlessings = func() Blessings {
- var native Blessings
- if err := vdl.Convert(&native, WireBlessings{}); err != nil {
- panic(err)
- }
- return native
- }()
- __VDLZeroWireDischarge = func() Discharge {
- var native Discharge
- if err := vdl.Convert(&native, WireDischarge(WireDischargePublicKey{})); err != nil {
- panic(err)
- }
- return native
- }()
- __VDLZeroRejectedBlessing = RejectedBlessing{}
-)
+func (t *RejectedBlessingTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = RejectedBlessing{}
+ return nil
+}
// Type-check native conversion functions.
var (
@@ -1959,6 +2303,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register native type conversions first, so that vdl.TypeOf works.
vdl.RegisterNative(WireBlessingsToNative, WireBlessingsFromNative)
diff --git a/services/appcycle/.api b/services/appcycle/.api
index 6c4b7b2..f9c4269 100644
--- a/services/appcycle/.api
+++ b/services/appcycle/.api
@@ -6,14 +6,15 @@
pkg appcycle, method (*Task) MakeVDLTarget() vdl.Target
pkg appcycle, method (*TaskTarget) FinishField(vdl.Target, vdl.Target) error
pkg appcycle, method (*TaskTarget) FinishFields(vdl.FieldsTarget) error
+pkg appcycle, method (*TaskTarget) FromZero(*vdl.Type) error
pkg appcycle, method (*TaskTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg appcycle, method (*TaskTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg appcycle, type AppCycleClientMethods interface { ForceStop, Stop }
pkg appcycle, type AppCycleClientMethods interface, ForceStop(*context.T, ...rpc.CallOpt) error
pkg appcycle, type AppCycleClientMethods interface, Stop(*context.T, ...rpc.CallOpt) (AppCycleStopClientCall, error)
-pkg appcycle, type AppCycleClientStub interface { ForceStop, Stop }
pkg appcycle, type AppCycleClientStub interface, ForceStop(*context.T, ...rpc.CallOpt) error
pkg appcycle, type AppCycleClientStub interface, Stop(*context.T, ...rpc.CallOpt) (AppCycleStopClientCall, error)
+pkg appcycle, type AppCycleClientStub interface, unexported methods
pkg appcycle, type AppCycleServerMethods interface { ForceStop, Stop }
pkg appcycle, type AppCycleServerMethods interface, ForceStop(*context.T, rpc.ServerCall) error
pkg appcycle, type AppCycleServerMethods interface, Stop(*context.T, AppCycleStopServerCall) error
@@ -29,14 +30,8 @@
pkg appcycle, type AppCycleStopClientCall interface, RecvStream() interface { Advance() bool;; Value() Task;; Err() error;}
pkg appcycle, type AppCycleStopClientStream interface { RecvStream }
pkg appcycle, type AppCycleStopClientStream interface, RecvStream() interface { Advance() bool;; Value() Task;; Err() error;}
-pkg appcycle, type AppCycleStopServerCall interface { GrantedBlessings, LocalEndpoint, RemoteEndpoint, Security, SendStream, Server, Suffix }
-pkg appcycle, type AppCycleStopServerCall interface, GrantedBlessings() security.Blessings
-pkg appcycle, type AppCycleStopServerCall interface, LocalEndpoint() naming.Endpoint
-pkg appcycle, type AppCycleStopServerCall interface, RemoteEndpoint() naming.Endpoint
-pkg appcycle, type AppCycleStopServerCall interface, Security() security.Call
pkg appcycle, type AppCycleStopServerCall interface, SendStream() interface { Send(item Task) error;}
-pkg appcycle, type AppCycleStopServerCall interface, Server() Server
-pkg appcycle, type AppCycleStopServerCall interface, Suffix() string
+pkg appcycle, type AppCycleStopServerCall interface, unexported methods
pkg appcycle, type AppCycleStopServerCallStub struct
pkg appcycle, type AppCycleStopServerCallStub struct, embedded rpc.StreamServerCall
pkg appcycle, type AppCycleStopServerStream interface { SendStream }
diff --git a/services/appcycle/appcycle.vdl.go b/services/appcycle/appcycle.vdl.go
index 9d655b1..afb53de 100644
--- a/services/appcycle/appcycle.vdl.go
+++ b/services/appcycle/appcycle.vdl.go
@@ -47,28 +47,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Progress")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromInt(int64(m.Progress), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Progress == int32(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromInt(int64(m.Progress), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Goal")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Goal")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromInt(int64(m.Goal), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Goal == int32(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromInt(int64(m.Goal), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -118,11 +133,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroTask = Task{}
-)
+func (t *TaskTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Task{}
+ return nil
+}
//////////////////////////////////////////////////
// Interface definitions
@@ -397,6 +411,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*Task)(nil))
diff --git a/services/application/.api b/services/application/.api
index 6ea9973..aa19b28 100644
--- a/services/application/.api
+++ b/services/application/.api
@@ -4,6 +4,7 @@
pkg application, method (*Envelope) UnmarshalJSON([]byte) error
pkg application, method (*EnvelopeTarget) FinishField(vdl.Target, vdl.Target) error
pkg application, method (*EnvelopeTarget) FinishFields(vdl.FieldsTarget) error
+pkg application, method (*EnvelopeTarget) FromZero(*vdl.Type) error
pkg application, method (*EnvelopeTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg application, method (*EnvelopeTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg application, method (*Packages) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -11,12 +12,14 @@
pkg application, method (*PackagesTarget) FinishField(vdl.Target, vdl.Target) error
pkg application, method (*PackagesTarget) FinishKeyStartField(vdl.Target) (vdl.Target, error)
pkg application, method (*PackagesTarget) FinishMap(vdl.MapTarget) error
+pkg application, method (*PackagesTarget) FromZero(*vdl.Type) error
pkg application, method (*PackagesTarget) StartKey() (vdl.Target, error)
pkg application, method (*PackagesTarget) StartMap(*vdl.Type, int) (vdl.MapTarget, error)
pkg application, method (*SignedFile) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg application, method (*SignedFile) MakeVDLTarget() vdl.Target
pkg application, method (*SignedFileTarget) FinishField(vdl.Target, vdl.Target) error
pkg application, method (*SignedFileTarget) FinishFields(vdl.FieldsTarget) error
+pkg application, method (*SignedFileTarget) FromZero(*vdl.Type) error
pkg application, method (*SignedFileTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg application, method (*SignedFileTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg application, method (Envelope) MarshalJSON() ([]byte, error)
diff --git a/services/application/application.vdl.go b/services/application/application.vdl.go
index 01ad912..d05f0b7 100644
--- a/services/application/application.vdl.go
+++ b/services/application/application.vdl.go
@@ -40,29 +40,61 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("File")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.File), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.File == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.File), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Signature")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Signature")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Signature.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := true
+ var var8 bool
+ if len(m.Signature.Purpose) == 0 {
+ var8 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ var7 = var7 && var8
+ var9 := (m.Signature.Hash == security.Hash(""))
+ var7 = var7 && var9
+ var var10 bool
+ if len(m.Signature.R) == 0 {
+ var10 = true
+ }
+ var7 = var7 && var10
+ var var11 bool
+ if len(m.Signature.S) == 0 {
+ var11 = true
+ }
+ var7 = var7 && var11
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Signature.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -112,6 +144,10 @@
return nil
}
+func (t *SignedFileTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SignedFile{}
+ return nil
+}
// Packages represents a set of packages. The map key is the local
// file/directory name, relative to the instance's packages directory, where the
@@ -213,6 +249,10 @@
return nil
}
+func (t *PackagesTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Packages(nil)
+ return nil
+}
// Envelope is a collection of metadata that describes an application.
type Envelope struct {
@@ -263,148 +303,246 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Title")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Title), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Title == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Title), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Args")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Args")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget6, err := fieldTarget5.StartList(tt.NonOptional().Field(1).Type, len(m.Args))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.Args) == 0 {
+ var7 = true
}
- for i, elem8 := range m.Args {
- elemTarget7, err := listTarget6.StartElem(i)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.Args))
if err != nil {
return err
}
- if err := elemTarget7.FromString(string(elem8), tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ for i, elem10 := range m.Args {
+ elemTarget9, err := listTarget8.StartElem(i)
+ if err != nil {
+ return err
+ }
+ if err := elemTarget9.FromString(string(elem10), tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ return err
+ }
}
- if err := listTarget6.FinishElem(elemTarget7); err != nil {
+ if err := fieldTarget6.FinishList(listTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishList(listTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Binary")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Binary")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Binary.FillVDLTarget(fieldTarget10, tt.NonOptional().Field(2).Type); err != nil {
- return err
+ var13 := true
+ var14 := (m.Binary.File == "")
+ var13 = var13 && var14
+ var15 := true
+ var var16 bool
+ if len(m.Binary.Signature.Purpose) == 0 {
+ var16 = true
}
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
- return err
+ var15 = var15 && var16
+ var17 := (m.Binary.Signature.Hash == security.Hash(""))
+ var15 = var15 && var17
+ var var18 bool
+ if len(m.Binary.Signature.R) == 0 {
+ var18 = true
}
- }
- var wireValue11 security.WireBlessings
- if err := security.WireBlessingsFromNative(&wireValue11, m.Publisher); err != nil {
- return err
- }
-
- keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("Publisher")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
-
- if err := wireValue11.FillVDLTarget(fieldTarget13, tt.NonOptional().Field(3).Type); err != nil {
- return err
+ var15 = var15 && var18
+ var var19 bool
+ if len(m.Binary.Signature.S) == 0 {
+ var19 = true
}
- if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
- return err
- }
- }
- keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Env")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
-
- listTarget16, err := fieldTarget15.StartList(tt.NonOptional().Field(4).Type, len(m.Env))
- if err != nil {
- return err
- }
- for i, elem18 := range m.Env {
- elemTarget17, err := listTarget16.StartElem(i)
- if err != nil {
+ var15 = var15 && var19
+ var13 = var13 && var15
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(2).Type); err != nil {
return err
}
- if err := elemTarget17.FromString(string(elem18), tt.NonOptional().Field(4).Type.Elem()); err != nil {
- return err
- }
- if err := listTarget16.FinishElem(elemTarget17); err != nil {
+ } else {
+
+ if err := m.Binary.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(2).Type); err != nil {
return err
}
}
- if err := fieldTarget15.FinishList(listTarget16); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
- keyTarget19, fieldTarget20, err := fieldsTarget1.StartField("Packages")
+ var wireValue20 security.WireBlessings
+ if err := security.WireBlessingsFromNative(&wireValue20, m.Publisher); err != nil {
+ return err
+ }
+
+ keyTarget21, fieldTarget22, err := fieldsTarget1.StartField("Publisher")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Packages.FillVDLTarget(fieldTarget20, tt.NonOptional().Field(5).Type); err != nil {
- return err
+ var23 := true
+ var var24 bool
+ if len(wireValue20.CertificateChains) == 0 {
+ var24 = true
}
- if err := fieldsTarget1.FinishField(keyTarget19, fieldTarget20); err != nil {
- return err
- }
- }
- keyTarget21, fieldTarget22, err := fieldsTarget1.StartField("Restarts")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget22.FromInt(int64(m.Restarts), tt.NonOptional().Field(6).Type); err != nil {
- return err
+ var23 = var23 && var24
+ if var23 {
+ if err := fieldTarget22.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue20.FillVDLTarget(fieldTarget22, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget21, fieldTarget22); err != nil {
return err
}
}
- var wireValue23 time_2.Duration
- if err := time_2.DurationFromNative(&wireValue23, m.RestartTimeWindow); err != nil {
- return err
- }
-
- keyTarget24, fieldTarget25, err := fieldsTarget1.StartField("RestartTimeWindow")
+ keyTarget25, fieldTarget26, err := fieldsTarget1.StartField("Env")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue23.FillVDLTarget(fieldTarget25, tt.NonOptional().Field(7).Type); err != nil {
+ var var27 bool
+ if len(m.Env) == 0 {
+ var27 = true
+ }
+ if var27 {
+ if err := fieldTarget26.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget28, err := fieldTarget26.StartList(tt.NonOptional().Field(4).Type, len(m.Env))
+ if err != nil {
+ return err
+ }
+ for i, elem30 := range m.Env {
+ elemTarget29, err := listTarget28.StartElem(i)
+ if err != nil {
+ return err
+ }
+ if err := elemTarget29.FromString(string(elem30), tt.NonOptional().Field(4).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget28.FinishElem(elemTarget29); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget26.FinishList(listTarget28); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget25, fieldTarget26); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget24, fieldTarget25); err != nil {
+ }
+ keyTarget31, fieldTarget32, err := fieldsTarget1.StartField("Packages")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var33 bool
+ if len(m.Packages) == 0 {
+ var33 = true
+ }
+ if var33 {
+ if err := fieldTarget32.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Packages.FillVDLTarget(fieldTarget32, tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget31, fieldTarget32); err != nil {
+ return err
+ }
+ }
+ keyTarget34, fieldTarget35, err := fieldsTarget1.StartField("Restarts")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var36 := (m.Restarts == int32(0))
+ if var36 {
+ if err := fieldTarget35.FromZero(tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget35.FromInt(int64(m.Restarts), tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget34, fieldTarget35); err != nil {
+ return err
+ }
+ }
+ var wireValue37 time_2.Duration
+ if err := time_2.DurationFromNative(&wireValue37, m.RestartTimeWindow); err != nil {
+ return err
+ }
+
+ keyTarget38, fieldTarget39, err := fieldsTarget1.StartField("RestartTimeWindow")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var40 := (wireValue37 == time_2.Duration{})
+ if var40 {
+ if err := fieldTarget39.FromZero(tt.NonOptional().Field(7).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue37.FillVDLTarget(fieldTarget39, tt.NonOptional().Field(7).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget38, fieldTarget39); err != nil {
return err
}
}
@@ -484,13 +622,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroSignedFile = SignedFile{}
- __VDLZeroPackages = Packages(nil)
- __VDLZeroEnvelope = Envelope{}
-)
+func (t *EnvelopeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Envelope{}
+ return nil
+}
//////////////////////////////////////////////////
// Const definitions
@@ -517,6 +652,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*SignedFile)(nil))
diff --git a/services/binary/.api b/services/binary/.api
index f339769..86a3c5d 100644
--- a/services/binary/.api
+++ b/services/binary/.api
@@ -4,12 +4,14 @@
pkg binary, method (*Description) MakeVDLTarget() vdl.Target
pkg binary, method (*DescriptionTarget) FinishField(vdl.Target, vdl.Target) error
pkg binary, method (*DescriptionTarget) FinishFields(vdl.FieldsTarget) error
+pkg binary, method (*DescriptionTarget) FromZero(*vdl.Type) error
pkg binary, method (*DescriptionTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg binary, method (*DescriptionTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg binary, method (*PartInfo) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg binary, method (*PartInfo) MakeVDLTarget() vdl.Target
pkg binary, method (*PartInfoTarget) FinishField(vdl.Target, vdl.Target) error
pkg binary, method (*PartInfoTarget) FinishFields(vdl.FieldsTarget) error
+pkg binary, method (*PartInfoTarget) FromZero(*vdl.Type) error
pkg binary, method (*PartInfoTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg binary, method (*PartInfoTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg binary, type Description struct
diff --git a/services/binary/binary.vdl.go b/services/binary/binary.vdl.go
index db95aea..eac8960 100644
--- a/services/binary/binary.vdl.go
+++ b/services/binary/binary.vdl.go
@@ -50,52 +50,70 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Profiles")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Profiles")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget6, err := fieldTarget5.StartMap(tt.NonOptional().Field(1).Type, len(m.Profiles))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.Profiles) == 0 {
+ var7 = true
}
- for key8, value10 := range m.Profiles {
- keyTarget7, err := mapTarget6.StartKey()
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget8, err := fieldTarget6.StartMap(tt.NonOptional().Field(1).Type, len(m.Profiles))
if err != nil {
return err
}
- if err := keyTarget7.FromString(string(key8), tt.NonOptional().Field(1).Type.Key()); err != nil {
- return err
+ for key10, value12 := range m.Profiles {
+ keyTarget9, err := mapTarget8.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget9.FromString(string(key10), tt.NonOptional().Field(1).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget11, err := mapTarget8.FinishKeyStartField(keyTarget9)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget11.FromBool(bool(value12), tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget8.FinishField(keyTarget9, valueTarget11); err != nil {
+ return err
+ }
}
- valueTarget9, err := mapTarget6.FinishKeyStartField(keyTarget7)
- if err != nil {
- return err
- }
- if err := valueTarget9.FromBool(bool(value10), tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget6.FinishField(keyTarget7, valueTarget9); err != nil {
+ if err := fieldTarget6.FinishMap(mapTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishMap(mapTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -145,6 +163,10 @@
return nil
}
+func (t *DescriptionTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Description{}
+ return nil
+}
// map[string]bool
type __VDLTarget1_map struct {
@@ -188,6 +210,10 @@
return nil
}
+func (t *__VDLTarget1_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[string]bool(nil)
+ return nil
+}
// PartInfo holds information describing a binary part.
type PartInfo struct {
@@ -207,28 +233,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Checksum")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Checksum), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Checksum == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Checksum), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Size")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Size")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromInt(int64(m.Size), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Size == int64(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromInt(int64(m.Size), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -278,12 +319,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroDescription = Description{}
- __VDLZeroPartInfo = PartInfo{}
-)
+func (t *PartInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = PartInfo{}
+ return nil
+}
//////////////////////////////////////////////////
// Const definitions
@@ -310,6 +349,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*Description)(nil))
diff --git a/services/build/.api b/services/build/.api
index 64aa9f2..e4c77c5 100644
--- a/services/build/.api
+++ b/services/build/.api
@@ -18,6 +18,7 @@
pkg build, method (*Architecture) Set(string) error
pkg build, method (*Architecture) SetFromGoArch(string) error
pkg build, method (*ArchitectureTarget) FromEnumLabel(string, *vdl.Type) error
+pkg build, method (*ArchitectureTarget) FromZero(*vdl.Type) error
pkg build, method (*BuilderBuildServerCallStub) Init(rpc.StreamServerCall)
pkg build, method (*BuilderBuildServerCallStub) RecvStream() interface { Advance() bool; Value() File; Err() error;}
pkg build, method (*BuilderBuildServerCallStub) SendStream() interface { Send(item File) error;}
@@ -25,17 +26,20 @@
pkg build, method (*File) MakeVDLTarget() vdl.Target
pkg build, method (*FileTarget) FinishField(vdl.Target, vdl.Target) error
pkg build, method (*FileTarget) FinishFields(vdl.FieldsTarget) error
+pkg build, method (*FileTarget) FromZero(*vdl.Type) error
pkg build, method (*FileTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg build, method (*FileTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg build, method (*Format) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg build, method (*Format) MakeVDLTarget() vdl.Target
pkg build, method (*Format) Set(string) error
pkg build, method (*FormatTarget) FromEnumLabel(string, *vdl.Type) error
+pkg build, method (*FormatTarget) FromZero(*vdl.Type) error
pkg build, method (*OperatingSystem) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg build, method (*OperatingSystem) MakeVDLTarget() vdl.Target
pkg build, method (*OperatingSystem) Set(string) error
pkg build, method (*OperatingSystem) SetFromGoOS(string) error
pkg build, method (*OperatingSystemTarget) FromEnumLabel(string, *vdl.Type) error
+pkg build, method (*OperatingSystemTarget) FromZero(*vdl.Type) error
pkg build, method (Architecture) String() string
pkg build, method (Architecture) ToGoArch() string
pkg build, method (Format) String() string
@@ -52,15 +56,9 @@
pkg build, type BuilderBuildClientStream interface { RecvStream, SendStream }
pkg build, type BuilderBuildClientStream interface, RecvStream() interface { Advance() bool;; Value() File;; Err() error;}
pkg build, type BuilderBuildClientStream interface, SendStream() interface { Send(item File) error;; Close() error;}
-pkg build, type BuilderBuildServerCall interface { GrantedBlessings, LocalEndpoint, RecvStream, RemoteEndpoint, Security, SendStream, Server, Suffix }
-pkg build, type BuilderBuildServerCall interface, GrantedBlessings() security.Blessings
-pkg build, type BuilderBuildServerCall interface, LocalEndpoint() naming.Endpoint
pkg build, type BuilderBuildServerCall interface, RecvStream() interface { Advance() bool;; Value() File;; Err() error;}
-pkg build, type BuilderBuildServerCall interface, RemoteEndpoint() naming.Endpoint
-pkg build, type BuilderBuildServerCall interface, Security() security.Call
pkg build, type BuilderBuildServerCall interface, SendStream() interface { Send(item File) error;}
-pkg build, type BuilderBuildServerCall interface, Server() Server
-pkg build, type BuilderBuildServerCall interface, Suffix() string
+pkg build, type BuilderBuildServerCall interface, unexported methods
pkg build, type BuilderBuildServerCallStub struct
pkg build, type BuilderBuildServerCallStub struct, embedded rpc.StreamServerCall
pkg build, type BuilderBuildServerStream interface { RecvStream, SendStream }
@@ -69,9 +67,9 @@
pkg build, type BuilderClientMethods interface { Build, Describe }
pkg build, type BuilderClientMethods interface, Build(*context.T, Architecture, OperatingSystem, ...rpc.CallOpt) (BuilderBuildClientCall, error)
pkg build, type BuilderClientMethods interface, Describe(*context.T, string, ...rpc.CallOpt) (binary.Description, error)
-pkg build, type BuilderClientStub interface { Build, Describe }
pkg build, type BuilderClientStub interface, Build(*context.T, Architecture, OperatingSystem, ...rpc.CallOpt) (BuilderBuildClientCall, error)
pkg build, type BuilderClientStub interface, Describe(*context.T, string, ...rpc.CallOpt) (binary.Description, error)
+pkg build, type BuilderClientStub interface, unexported methods
pkg build, type BuilderServerMethods interface { Build, Describe }
pkg build, type BuilderServerMethods interface, Build(*context.T, BuilderBuildServerCall, Architecture, OperatingSystem) ([]byte, error)
pkg build, type BuilderServerMethods interface, Describe(*context.T, rpc.ServerCall, string) (binary.Description, error)
diff --git a/services/build/build.vdl.go b/services/build/build.vdl.go
index fb97627..1d7548d 100644
--- a/services/build/build.vdl.go
+++ b/services/build/build.vdl.go
@@ -106,11 +106,15 @@
case "X86":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum v.io/v23/services/build.Architecture", src)
+ return fmt.Errorf("label %s not in enum Architecture", src)
}
return nil
}
+func (t *ArchitectureTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ArchitectureAmd64
+ return nil
+}
// Format specifies the file format of a host.
type Format int
@@ -195,11 +199,15 @@
case "Pe":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum v.io/v23/services/build.Format", src)
+ return fmt.Errorf("label %s not in enum Format", src)
}
return nil
}
+func (t *FormatTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = FormatElf
+ return nil
+}
// OperatingSystem specifies the operating system of a host.
type OperatingSystem int
@@ -292,11 +300,15 @@
case "Android":
*t.Value = 3
default:
- return fmt.Errorf("label %s not in enum v.io/v23/services/build.OperatingSystem", src)
+ return fmt.Errorf("label %s not in enum OperatingSystem", src)
}
return nil
}
+func (t *OperatingSystemTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = OperatingSystemDarwin
+ return nil
+}
// File records the name and contents of a file.
type File struct {
@@ -314,29 +326,47 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Contents")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Contents")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromBytes([]byte(m.Contents), tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var var7 bool
+ if len(m.Contents) == 0 {
+ var7 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget6.FromBytes([]byte(m.Contents), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -386,14 +416,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroArchitecture = ArchitectureAmd64
- __VDLZeroFormat = FormatElf
- __VDLZeroOperatingSystem = OperatingSystemDarwin
- __VDLZeroFile = File{}
-)
+func (t *FileTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = File{}
+ return nil
+}
//////////////////////////////////////////////////
// Interface definitions
@@ -751,6 +777,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*Architecture)(nil))
diff --git a/services/device/.api b/services/device/.api
index 8ca6185..5897c02 100644
--- a/services/device/.api
+++ b/services/device/.api
@@ -21,14 +21,17 @@
pkg device, method (*Association) MakeVDLTarget() vdl.Target
pkg device, method (*AssociationTarget) FinishField(vdl.Target, vdl.Target) error
pkg device, method (*AssociationTarget) FinishFields(vdl.FieldsTarget) error
+pkg device, method (*AssociationTarget) FromZero(*vdl.Type) error
pkg device, method (*AssociationTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg device, method (*AssociationTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg device, method (*BlessClientMessageTarget) FinishField(vdl.Target, vdl.Target) error
pkg device, method (*BlessClientMessageTarget) FinishFields(vdl.FieldsTarget) error
+pkg device, method (*BlessClientMessageTarget) FromZero(*vdl.Type) error
pkg device, method (*BlessClientMessageTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg device, method (*BlessClientMessageTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg device, method (*BlessServerMessageTarget) FinishField(vdl.Target, vdl.Target) error
pkg device, method (*BlessServerMessageTarget) FinishFields(vdl.FieldsTarget) error
+pkg device, method (*BlessServerMessageTarget) FromZero(*vdl.Type) error
pkg device, method (*BlessServerMessageTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg device, method (*BlessServerMessageTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg device, method (*Config) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -36,42 +39,50 @@
pkg device, method (*ConfigTarget) FinishField(vdl.Target, vdl.Target) error
pkg device, method (*ConfigTarget) FinishKeyStartField(vdl.Target) (vdl.Target, error)
pkg device, method (*ConfigTarget) FinishMap(vdl.MapTarget) error
+pkg device, method (*ConfigTarget) FromZero(*vdl.Type) error
pkg device, method (*ConfigTarget) StartKey() (vdl.Target, error)
pkg device, method (*ConfigTarget) StartMap(*vdl.Type, int) (vdl.MapTarget, error)
pkg device, method (*Description) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg device, method (*Description) MakeVDLTarget() vdl.Target
pkg device, method (*DescriptionTarget) FinishField(vdl.Target, vdl.Target) error
pkg device, method (*DescriptionTarget) FinishFields(vdl.FieldsTarget) error
+pkg device, method (*DescriptionTarget) FromZero(*vdl.Type) error
pkg device, method (*DescriptionTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg device, method (*DescriptionTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg device, method (*DeviceStatus) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg device, method (*DeviceStatus) MakeVDLTarget() vdl.Target
pkg device, method (*DeviceStatusTarget) FinishField(vdl.Target, vdl.Target) error
pkg device, method (*DeviceStatusTarget) FinishFields(vdl.FieldsTarget) error
+pkg device, method (*DeviceStatusTarget) FromZero(*vdl.Type) error
pkg device, method (*DeviceStatusTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg device, method (*DeviceStatusTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg device, method (*InstallationState) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg device, method (*InstallationState) MakeVDLTarget() vdl.Target
pkg device, method (*InstallationState) Set(string) error
pkg device, method (*InstallationStateTarget) FromEnumLabel(string, *vdl.Type) error
+pkg device, method (*InstallationStateTarget) FromZero(*vdl.Type) error
pkg device, method (*InstallationStatus) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg device, method (*InstallationStatus) MakeVDLTarget() vdl.Target
pkg device, method (*InstallationStatusTarget) FinishField(vdl.Target, vdl.Target) error
pkg device, method (*InstallationStatusTarget) FinishFields(vdl.FieldsTarget) error
+pkg device, method (*InstallationStatusTarget) FromZero(*vdl.Type) error
pkg device, method (*InstallationStatusTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg device, method (*InstallationStatusTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg device, method (*InstanceState) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg device, method (*InstanceState) MakeVDLTarget() vdl.Target
pkg device, method (*InstanceState) Set(string) error
pkg device, method (*InstanceStateTarget) FromEnumLabel(string, *vdl.Type) error
+pkg device, method (*InstanceStateTarget) FromZero(*vdl.Type) error
pkg device, method (*InstanceStatus) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg device, method (*InstanceStatus) MakeVDLTarget() vdl.Target
pkg device, method (*InstanceStatusTarget) FinishField(vdl.Target, vdl.Target) error
pkg device, method (*InstanceStatusTarget) FinishFields(vdl.FieldsTarget) error
+pkg device, method (*InstanceStatusTarget) FromZero(*vdl.Type) error
pkg device, method (*InstanceStatusTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg device, method (*InstanceStatusTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg device, method (*StatusTarget) FinishField(vdl.Target, vdl.Target) error
pkg device, method (*StatusTarget) FinishFields(vdl.FieldsTarget) error
+pkg device, method (*StatusTarget) FromZero(*vdl.Type) error
pkg device, method (*StatusTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg device, method (*StatusTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg device, method (BlessClientMessageAppBlessings) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -101,34 +112,30 @@
pkg device, method (StatusInstance) Interface() interface{}
pkg device, method (StatusInstance) MakeVDLTarget() vdl.Target
pkg device, method (StatusInstance) Name() string
-pkg device, type ApplicationClientMethods interface { Debug, Delete, GetPermissions, Install, Instantiate, Kill, Revert, Run, SetPermissions, Status, Uninstall, Update, UpdateTo }
pkg device, type ApplicationClientMethods interface, Debug(*context.T, ...rpc.CallOpt) (string, error)
pkg device, type ApplicationClientMethods interface, Delete(*context.T, ...rpc.CallOpt) error
-pkg device, type ApplicationClientMethods interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
pkg device, type ApplicationClientMethods interface, Install(*context.T, string, Config, application.Packages, ...rpc.CallOpt) (string, error)
pkg device, type ApplicationClientMethods interface, Instantiate(*context.T, ...rpc.CallOpt) (ApplicationInstantiateClientCall, error)
pkg device, type ApplicationClientMethods interface, Kill(*context.T, time.Duration, ...rpc.CallOpt) error
pkg device, type ApplicationClientMethods interface, Revert(*context.T, ...rpc.CallOpt) error
pkg device, type ApplicationClientMethods interface, Run(*context.T, ...rpc.CallOpt) error
-pkg device, type ApplicationClientMethods interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
pkg device, type ApplicationClientMethods interface, Status(*context.T, ...rpc.CallOpt) (Status, error)
pkg device, type ApplicationClientMethods interface, Uninstall(*context.T, ...rpc.CallOpt) error
pkg device, type ApplicationClientMethods interface, Update(*context.T, ...rpc.CallOpt) error
pkg device, type ApplicationClientMethods interface, UpdateTo(*context.T, string, ...rpc.CallOpt) error
-pkg device, type ApplicationClientStub interface { Debug, Delete, GetPermissions, Install, Instantiate, Kill, Revert, Run, SetPermissions, Status, Uninstall, Update, UpdateTo }
+pkg device, type ApplicationClientMethods interface, unexported methods
pkg device, type ApplicationClientStub interface, Debug(*context.T, ...rpc.CallOpt) (string, error)
pkg device, type ApplicationClientStub interface, Delete(*context.T, ...rpc.CallOpt) error
-pkg device, type ApplicationClientStub interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
pkg device, type ApplicationClientStub interface, Install(*context.T, string, Config, application.Packages, ...rpc.CallOpt) (string, error)
pkg device, type ApplicationClientStub interface, Instantiate(*context.T, ...rpc.CallOpt) (ApplicationInstantiateClientCall, error)
pkg device, type ApplicationClientStub interface, Kill(*context.T, time.Duration, ...rpc.CallOpt) error
pkg device, type ApplicationClientStub interface, Revert(*context.T, ...rpc.CallOpt) error
pkg device, type ApplicationClientStub interface, Run(*context.T, ...rpc.CallOpt) error
-pkg device, type ApplicationClientStub interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
pkg device, type ApplicationClientStub interface, Status(*context.T, ...rpc.CallOpt) (Status, error)
pkg device, type ApplicationClientStub interface, Uninstall(*context.T, ...rpc.CallOpt) error
pkg device, type ApplicationClientStub interface, Update(*context.T, ...rpc.CallOpt) error
pkg device, type ApplicationClientStub interface, UpdateTo(*context.T, string, ...rpc.CallOpt) error
+pkg device, type ApplicationClientStub interface, unexported methods
pkg device, type ApplicationInstantiateClientCall interface { Finish, RecvStream, SendStream }
pkg device, type ApplicationInstantiateClientCall interface, Finish() (string, error)
pkg device, type ApplicationInstantiateClientCall interface, RecvStream() interface { Advance() bool;; Value() BlessServerMessage;; Err() error;}
@@ -136,34 +143,26 @@
pkg device, type ApplicationInstantiateClientStream interface { RecvStream, SendStream }
pkg device, type ApplicationInstantiateClientStream interface, RecvStream() interface { Advance() bool;; Value() BlessServerMessage;; Err() error;}
pkg device, type ApplicationInstantiateClientStream interface, SendStream() interface { Send(item BlessClientMessage) error;; Close() error;}
-pkg device, type ApplicationInstantiateServerCall interface { GrantedBlessings, LocalEndpoint, RecvStream, RemoteEndpoint, Security, SendStream, Server, Suffix }
-pkg device, type ApplicationInstantiateServerCall interface, GrantedBlessings() security.Blessings
-pkg device, type ApplicationInstantiateServerCall interface, LocalEndpoint() naming.Endpoint
pkg device, type ApplicationInstantiateServerCall interface, RecvStream() interface { Advance() bool;; Value() BlessClientMessage;; Err() error;}
-pkg device, type ApplicationInstantiateServerCall interface, RemoteEndpoint() naming.Endpoint
-pkg device, type ApplicationInstantiateServerCall interface, Security() security.Call
pkg device, type ApplicationInstantiateServerCall interface, SendStream() interface { Send(item BlessServerMessage) error;}
-pkg device, type ApplicationInstantiateServerCall interface, Server() Server
-pkg device, type ApplicationInstantiateServerCall interface, Suffix() string
+pkg device, type ApplicationInstantiateServerCall interface, unexported methods
pkg device, type ApplicationInstantiateServerCallStub struct
pkg device, type ApplicationInstantiateServerCallStub struct, embedded rpc.StreamServerCall
pkg device, type ApplicationInstantiateServerStream interface { RecvStream, SendStream }
pkg device, type ApplicationInstantiateServerStream interface, RecvStream() interface { Advance() bool;; Value() BlessClientMessage;; Err() error;}
pkg device, type ApplicationInstantiateServerStream interface, SendStream() interface { Send(item BlessServerMessage) error;}
-pkg device, type ApplicationServerMethods interface { Debug, Delete, GetPermissions, Install, Instantiate, Kill, Revert, Run, SetPermissions, Status, Uninstall, Update, UpdateTo }
pkg device, type ApplicationServerMethods interface, Debug(*context.T, rpc.ServerCall) (string, error)
pkg device, type ApplicationServerMethods interface, Delete(*context.T, rpc.ServerCall) error
-pkg device, type ApplicationServerMethods interface, GetPermissions(*context.T, rpc.ServerCall) (access.Permissions, string, error)
pkg device, type ApplicationServerMethods interface, Install(*context.T, rpc.ServerCall, string, Config, application.Packages) (string, error)
pkg device, type ApplicationServerMethods interface, Instantiate(*context.T, ApplicationInstantiateServerCall) (string, error)
pkg device, type ApplicationServerMethods interface, Kill(*context.T, rpc.ServerCall, time.Duration) error
pkg device, type ApplicationServerMethods interface, Revert(*context.T, rpc.ServerCall) error
pkg device, type ApplicationServerMethods interface, Run(*context.T, rpc.ServerCall) error
-pkg device, type ApplicationServerMethods interface, SetPermissions(*context.T, rpc.ServerCall, access.Permissions, string) error
pkg device, type ApplicationServerMethods interface, Status(*context.T, rpc.ServerCall) (Status, error)
pkg device, type ApplicationServerMethods interface, Uninstall(*context.T, rpc.ServerCall) error
pkg device, type ApplicationServerMethods interface, Update(*context.T, rpc.ServerCall) error
pkg device, type ApplicationServerMethods interface, UpdateTo(*context.T, rpc.ServerCall, string) error
+pkg device, type ApplicationServerMethods interface, unexported methods
pkg device, type ApplicationServerStub interface, Debug(*context.T, rpc.ServerCall) (string, error)
pkg device, type ApplicationServerStub interface, Delete(*context.T, rpc.ServerCall) error
pkg device, type ApplicationServerStub interface, Describe__() []rpc.InterfaceDesc
@@ -220,8 +219,8 @@
pkg device, type BlessServerMessageTarget struct, embedded vdl.TargetBase
pkg device, type ClaimableClientMethods interface { Claim }
pkg device, type ClaimableClientMethods interface, Claim(*context.T, string, ...rpc.CallOpt) error
-pkg device, type ClaimableClientStub interface { Claim }
pkg device, type ClaimableClientStub interface, Claim(*context.T, string, ...rpc.CallOpt) error
+pkg device, type ClaimableClientStub interface, unexported methods
pkg device, type ClaimableServerMethods interface { Claim }
pkg device, type ClaimableServerMethods interface, Claim(*context.T, rpc.ServerCall, string) error
pkg device, type ClaimableServerStub interface, Describe__() []rpc.InterfaceDesc
@@ -238,12 +237,10 @@
pkg device, type DescriptionTarget struct, Value *Description
pkg device, type DescriptionTarget struct, embedded vdl.FieldsTargetBase
pkg device, type DescriptionTarget struct, embedded vdl.TargetBase
-pkg device, type DeviceClientMethods interface { AssociateAccount, Debug, Delete, Describe, GetPermissions, Install, Instantiate, IsRunnable, Kill, ListAssociations, Reset, Revert, Run, SetPermissions, Status, TidyNow, Uninstall, Update, UpdateTo }
pkg device, type DeviceClientMethods interface, AssociateAccount(*context.T, []string, string, ...rpc.CallOpt) error
pkg device, type DeviceClientMethods interface, Debug(*context.T, ...rpc.CallOpt) (string, error)
pkg device, type DeviceClientMethods interface, Delete(*context.T, ...rpc.CallOpt) error
pkg device, type DeviceClientMethods interface, Describe(*context.T, ...rpc.CallOpt) (Description, error)
-pkg device, type DeviceClientMethods interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
pkg device, type DeviceClientMethods interface, Install(*context.T, string, Config, application.Packages, ...rpc.CallOpt) (string, error)
pkg device, type DeviceClientMethods interface, Instantiate(*context.T, ...rpc.CallOpt) (ApplicationInstantiateClientCall, error)
pkg device, type DeviceClientMethods interface, IsRunnable(*context.T, binary.Description, ...rpc.CallOpt) (bool, error)
@@ -252,18 +249,15 @@
pkg device, type DeviceClientMethods interface, Reset(*context.T, time.Duration, ...rpc.CallOpt) error
pkg device, type DeviceClientMethods interface, Revert(*context.T, ...rpc.CallOpt) error
pkg device, type DeviceClientMethods interface, Run(*context.T, ...rpc.CallOpt) error
-pkg device, type DeviceClientMethods interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
pkg device, type DeviceClientMethods interface, Status(*context.T, ...rpc.CallOpt) (Status, error)
-pkg device, type DeviceClientMethods interface, TidyNow(*context.T, ...rpc.CallOpt) error
pkg device, type DeviceClientMethods interface, Uninstall(*context.T, ...rpc.CallOpt) error
pkg device, type DeviceClientMethods interface, Update(*context.T, ...rpc.CallOpt) error
pkg device, type DeviceClientMethods interface, UpdateTo(*context.T, string, ...rpc.CallOpt) error
-pkg device, type DeviceClientStub interface { AssociateAccount, Debug, Delete, Describe, GetPermissions, Install, Instantiate, IsRunnable, Kill, ListAssociations, Reset, Revert, Run, SetPermissions, Status, TidyNow, Uninstall, Update, UpdateTo }
+pkg device, type DeviceClientMethods interface, unexported methods
pkg device, type DeviceClientStub interface, AssociateAccount(*context.T, []string, string, ...rpc.CallOpt) error
pkg device, type DeviceClientStub interface, Debug(*context.T, ...rpc.CallOpt) (string, error)
pkg device, type DeviceClientStub interface, Delete(*context.T, ...rpc.CallOpt) error
pkg device, type DeviceClientStub interface, Describe(*context.T, ...rpc.CallOpt) (Description, error)
-pkg device, type DeviceClientStub interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
pkg device, type DeviceClientStub interface, Install(*context.T, string, Config, application.Packages, ...rpc.CallOpt) (string, error)
pkg device, type DeviceClientStub interface, Instantiate(*context.T, ...rpc.CallOpt) (ApplicationInstantiateClientCall, error)
pkg device, type DeviceClientStub interface, IsRunnable(*context.T, binary.Description, ...rpc.CallOpt) (bool, error)
@@ -272,18 +266,15 @@
pkg device, type DeviceClientStub interface, Reset(*context.T, time.Duration, ...rpc.CallOpt) error
pkg device, type DeviceClientStub interface, Revert(*context.T, ...rpc.CallOpt) error
pkg device, type DeviceClientStub interface, Run(*context.T, ...rpc.CallOpt) error
-pkg device, type DeviceClientStub interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
pkg device, type DeviceClientStub interface, Status(*context.T, ...rpc.CallOpt) (Status, error)
-pkg device, type DeviceClientStub interface, TidyNow(*context.T, ...rpc.CallOpt) error
pkg device, type DeviceClientStub interface, Uninstall(*context.T, ...rpc.CallOpt) error
pkg device, type DeviceClientStub interface, Update(*context.T, ...rpc.CallOpt) error
pkg device, type DeviceClientStub interface, UpdateTo(*context.T, string, ...rpc.CallOpt) error
-pkg device, type DeviceServerMethods interface { AssociateAccount, Debug, Delete, Describe, GetPermissions, Install, Instantiate, IsRunnable, Kill, ListAssociations, Reset, Revert, Run, SetPermissions, Status, TidyNow, Uninstall, Update, UpdateTo }
+pkg device, type DeviceClientStub interface, unexported methods
pkg device, type DeviceServerMethods interface, AssociateAccount(*context.T, rpc.ServerCall, []string, string) error
pkg device, type DeviceServerMethods interface, Debug(*context.T, rpc.ServerCall) (string, error)
pkg device, type DeviceServerMethods interface, Delete(*context.T, rpc.ServerCall) error
pkg device, type DeviceServerMethods interface, Describe(*context.T, rpc.ServerCall) (Description, error)
-pkg device, type DeviceServerMethods interface, GetPermissions(*context.T, rpc.ServerCall) (access.Permissions, string, error)
pkg device, type DeviceServerMethods interface, Install(*context.T, rpc.ServerCall, string, Config, application.Packages) (string, error)
pkg device, type DeviceServerMethods interface, Instantiate(*context.T, ApplicationInstantiateServerCall) (string, error)
pkg device, type DeviceServerMethods interface, IsRunnable(*context.T, rpc.ServerCall, binary.Description) (bool, error)
@@ -292,12 +283,11 @@
pkg device, type DeviceServerMethods interface, Reset(*context.T, rpc.ServerCall, time.Duration) error
pkg device, type DeviceServerMethods interface, Revert(*context.T, rpc.ServerCall) error
pkg device, type DeviceServerMethods interface, Run(*context.T, rpc.ServerCall) error
-pkg device, type DeviceServerMethods interface, SetPermissions(*context.T, rpc.ServerCall, access.Permissions, string) error
pkg device, type DeviceServerMethods interface, Status(*context.T, rpc.ServerCall) (Status, error)
-pkg device, type DeviceServerMethods interface, TidyNow(*context.T, rpc.ServerCall) error
pkg device, type DeviceServerMethods interface, Uninstall(*context.T, rpc.ServerCall) error
pkg device, type DeviceServerMethods interface, Update(*context.T, rpc.ServerCall) error
pkg device, type DeviceServerMethods interface, UpdateTo(*context.T, rpc.ServerCall, string) error
+pkg device, type DeviceServerMethods interface, unexported methods
pkg device, type DeviceServerStub interface, AssociateAccount(*context.T, rpc.ServerCall, []string, string) error
pkg device, type DeviceServerStub interface, Debug(*context.T, rpc.ServerCall) (string, error)
pkg device, type DeviceServerStub interface, Delete(*context.T, rpc.ServerCall) error
diff --git a/services/device/device.vdl.go b/services/device/device.vdl.go
index cda04df..d672d88 100644
--- a/services/device/device.vdl.go
+++ b/services/device/device.vdl.go
@@ -114,6 +114,10 @@
return nil
}
+func (t *ConfigTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Config(nil)
+ return nil
+}
// InstallationState describes the states that an installation can be in at any
// time.
@@ -191,11 +195,15 @@
case "Uninstalled":
*t.Value = 1
default:
- return fmt.Errorf("label %s not in enum v.io/v23/services/device.InstallationState", src)
+ return fmt.Errorf("label %s not in enum InstallationState", src)
}
return nil
}
+func (t *InstallationStateTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = InstallationStateActive
+ return nil
+}
// InstanceState describes the states that an instance can be in at any
// time.
@@ -305,11 +313,15 @@
case "Deleted":
*t.Value = 5
default:
- return fmt.Errorf("label %s not in enum v.io/v23/services/device.InstanceState", src)
+ return fmt.Errorf("label %s not in enum InstanceState", src)
}
return nil
}
+func (t *InstanceStateTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = InstanceStateLaunching
+ return nil
+}
// InstanceStatus specifies the Status returned by the Application Status method
// for instance objects.
@@ -328,29 +340,44 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("State")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.State == InstanceStateLaunching)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Version")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Version")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Version), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Version == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Version), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -400,6 +427,10 @@
return nil
}
+func (t *InstanceStatusTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = InstanceStatus{}
+ return nil
+}
// InstallationStatus specifies the Status returned by the Application Status
// method for installation objects.
@@ -418,29 +449,44 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("State")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.State == InstallationStateActive)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Version")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Version")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Version), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Version == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Version), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -490,6 +536,10 @@
return nil
}
+func (t *InstallationStatusTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = InstallationStatus{}
+ return nil
+}
// DeviceStatus specifies the Status returned by the Application Status method
// for the device service object.
@@ -508,29 +558,44 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("State")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.State == InstanceStateLaunching)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Version")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Version")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Version), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Version == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Version), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -580,6 +645,10 @@
return nil
}
+func (t *DeviceStatusTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = DeviceStatus{}
+ return nil
+}
type (
// Status represents any single field of the Status union type.
@@ -757,6 +826,10 @@
return nil
}
+func (t *StatusTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Status(StatusInstance{})
+ return nil
+}
type statusTargetFactory struct{}
@@ -868,6 +941,10 @@
return nil
}
+func (t *BlessServerMessageTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BlessServerMessage(BlessServerMessageInstancePublicKey{})
+ return nil
+}
type blessServerMessageTargetFactory struct{}
@@ -989,6 +1066,10 @@
return nil
}
+func (t *BlessClientMessageTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BlessClientMessage(BlessClientMessageAppBlessings{})
+ return nil
+}
type blessClientMessageTargetFactory struct{}
@@ -1022,31 +1103,41 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Profiles")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget4, err := fieldTarget3.StartSet(tt.NonOptional().Field(0).Type, len(m.Profiles))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.Profiles) == 0 {
+ var4 = true
}
- for key6 := range m.Profiles {
- keyTarget5, err := setTarget4.StartKey()
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget5, err := fieldTarget3.StartSet(tt.NonOptional().Field(0).Type, len(m.Profiles))
if err != nil {
return err
}
- if err := keyTarget5.FromString(string(key6), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ for key7 := range m.Profiles {
+ keyTarget6, err := setTarget5.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget6.FromString(string(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget5.FinishKey(keyTarget6); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishSet(setTarget5); err != nil {
return err
}
- if err := setTarget4.FinishKey(keyTarget5); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishSet(setTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -1093,6 +1184,10 @@
return nil
}
+func (t *DescriptionTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Description{}
+ return nil
+}
// map[string]struct{}
type __VDLTarget1_set struct {
@@ -1128,6 +1223,10 @@
return nil
}
+func (t *__VDLTarget1_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[string]struct{}(nil)
+ return nil
+}
// Association is a tuple containing an association between a Vanadium
// identity and a system account name.
@@ -1146,28 +1245,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("IdentityName")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.IdentityName), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.IdentityName == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.IdentityName), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("AccountName")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("AccountName")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.AccountName), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.AccountName == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.AccountName), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1217,21 +1331,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroConfig = Config(nil)
- __VDLZeroInstallationState = InstallationStateActive
- __VDLZeroInstanceState = InstanceStateLaunching
- __VDLZeroInstanceStatus = InstanceStatus{}
- __VDLZeroInstallationStatus = InstallationStatus{}
- __VDLZeroDeviceStatus = DeviceStatus{}
- __VDLZeroStatus = Status(StatusInstance{})
- __VDLZeroBlessServerMessage = BlessServerMessage(BlessServerMessageInstancePublicKey{})
- __VDLZeroBlessClientMessage = BlessClientMessage(BlessClientMessageAppBlessings{})
- __VDLZeroDescription = Description{}
- __VDLZeroAssociation = Association{}
-)
+func (t *AssociationTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Association{}
+ return nil
+}
//////////////////////////////////////////////////
// Interface definitions
@@ -2967,6 +3070,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*Config)(nil))
diff --git a/services/groups/.api b/services/groups/.api
index b12306e..d586a46 100644
--- a/services/groups/.api
+++ b/services/groups/.api
@@ -16,25 +16,30 @@
pkg groups, method (*Approximation) MakeVDLTarget() vdl.Target
pkg groups, method (*ApproximationTarget) FinishField(vdl.Target, vdl.Target) error
pkg groups, method (*ApproximationTarget) FinishFields(vdl.FieldsTarget) error
+pkg groups, method (*ApproximationTarget) FromZero(*vdl.Type) error
pkg groups, method (*ApproximationTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg groups, method (*ApproximationTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg groups, method (*ApproximationType) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg groups, method (*ApproximationType) MakeVDLTarget() vdl.Target
pkg groups, method (*ApproximationType) Set(string) error
pkg groups, method (*ApproximationTypeTarget) FromEnumLabel(string, *vdl.Type) error
+pkg groups, method (*ApproximationTypeTarget) FromZero(*vdl.Type) error
pkg groups, method (*BlessingPatternChunk) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg groups, method (*BlessingPatternChunk) MakeVDLTarget() vdl.Target
pkg groups, method (*BlessingPatternChunkTarget) FromString(string, *vdl.Type) error
+pkg groups, method (*BlessingPatternChunkTarget) FromZero(*vdl.Type) error
pkg groups, method (*GetRequest) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg groups, method (*GetRequest) MakeVDLTarget() vdl.Target
pkg groups, method (*GetRequestTarget) FinishField(vdl.Target, vdl.Target) error
pkg groups, method (*GetRequestTarget) FinishFields(vdl.FieldsTarget) error
+pkg groups, method (*GetRequestTarget) FromZero(*vdl.Type) error
pkg groups, method (*GetRequestTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg groups, method (*GetRequestTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg groups, method (*GetResponse) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg groups, method (*GetResponse) MakeVDLTarget() vdl.Target
pkg groups, method (*GetResponseTarget) FinishField(vdl.Target, vdl.Target) error
pkg groups, method (*GetResponseTarget) FinishFields(vdl.FieldsTarget) error
+pkg groups, method (*GetResponseTarget) FromZero(*vdl.Type) error
pkg groups, method (*GetResponseTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg groups, method (*GetResponseTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg groups, method (ApproximationType) String() string
@@ -64,51 +69,45 @@
pkg groups, type GetResponseTarget struct, Value *GetResponse
pkg groups, type GetResponseTarget struct, embedded vdl.FieldsTargetBase
pkg groups, type GetResponseTarget struct, embedded vdl.TargetBase
-pkg groups, type GroupClientMethods interface { Add, Create, Delete, Get, GetPermissions, Relate, Remove, SetPermissions }
pkg groups, type GroupClientMethods interface, Add(*context.T, BlessingPatternChunk, string, ...rpc.CallOpt) error
pkg groups, type GroupClientMethods interface, Create(*context.T, access.Permissions, []BlessingPatternChunk, ...rpc.CallOpt) error
pkg groups, type GroupClientMethods interface, Delete(*context.T, string, ...rpc.CallOpt) error
pkg groups, type GroupClientMethods interface, Get(*context.T, GetRequest, string, ...rpc.CallOpt) (GetResponse, string, error)
-pkg groups, type GroupClientMethods interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
pkg groups, type GroupClientMethods interface, Relate(*context.T, map[string]struct{}, ApproximationType, string, map[string]struct{}, ...rpc.CallOpt) (map[string]struct{}, []Approximation, string, error)
pkg groups, type GroupClientMethods interface, Remove(*context.T, BlessingPatternChunk, string, ...rpc.CallOpt) error
-pkg groups, type GroupClientMethods interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
-pkg groups, type GroupClientStub interface { Add, Create, Delete, Get, GetPermissions, Relate, Remove, SetPermissions }
+pkg groups, type GroupClientMethods interface, unexported methods
pkg groups, type GroupClientStub interface, Add(*context.T, BlessingPatternChunk, string, ...rpc.CallOpt) error
pkg groups, type GroupClientStub interface, Create(*context.T, access.Permissions, []BlessingPatternChunk, ...rpc.CallOpt) error
pkg groups, type GroupClientStub interface, Delete(*context.T, string, ...rpc.CallOpt) error
pkg groups, type GroupClientStub interface, Get(*context.T, GetRequest, string, ...rpc.CallOpt) (GetResponse, string, error)
-pkg groups, type GroupClientStub interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
pkg groups, type GroupClientStub interface, Relate(*context.T, map[string]struct{}, ApproximationType, string, map[string]struct{}, ...rpc.CallOpt) (map[string]struct{}, []Approximation, string, error)
pkg groups, type GroupClientStub interface, Remove(*context.T, BlessingPatternChunk, string, ...rpc.CallOpt) error
-pkg groups, type GroupClientStub interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
+pkg groups, type GroupClientStub interface, unexported methods
pkg groups, type GroupReaderClientMethods interface { Get, Relate }
pkg groups, type GroupReaderClientMethods interface, Get(*context.T, GetRequest, string, ...rpc.CallOpt) (GetResponse, string, error)
pkg groups, type GroupReaderClientMethods interface, Relate(*context.T, map[string]struct{}, ApproximationType, string, map[string]struct{}, ...rpc.CallOpt) (map[string]struct{}, []Approximation, string, error)
-pkg groups, type GroupReaderClientStub interface { Get, Relate }
pkg groups, type GroupReaderClientStub interface, Get(*context.T, GetRequest, string, ...rpc.CallOpt) (GetResponse, string, error)
pkg groups, type GroupReaderClientStub interface, Relate(*context.T, map[string]struct{}, ApproximationType, string, map[string]struct{}, ...rpc.CallOpt) (map[string]struct{}, []Approximation, string, error)
+pkg groups, type GroupReaderClientStub interface, unexported methods
pkg groups, type GroupReaderServerMethods interface { Get, Relate }
pkg groups, type GroupReaderServerMethods interface, Get(*context.T, rpc.ServerCall, GetRequest, string) (GetResponse, string, error)
pkg groups, type GroupReaderServerMethods interface, Relate(*context.T, rpc.ServerCall, map[string]struct{}, ApproximationType, string, map[string]struct{}) (map[string]struct{}, []Approximation, string, error)
pkg groups, type GroupReaderServerStub interface, Describe__() []rpc.InterfaceDesc
pkg groups, type GroupReaderServerStub interface, unexported methods
pkg groups, type GroupReaderServerStubMethods GroupReaderServerMethods
-pkg groups, type GroupServerMethods interface { Add, Create, Delete, Get, GetPermissions, Relate, Remove, SetPermissions }
pkg groups, type GroupServerMethods interface, Add(*context.T, rpc.ServerCall, BlessingPatternChunk, string) error
pkg groups, type GroupServerMethods interface, Create(*context.T, rpc.ServerCall, access.Permissions, []BlessingPatternChunk) error
pkg groups, type GroupServerMethods interface, Delete(*context.T, rpc.ServerCall, string) error
pkg groups, type GroupServerMethods interface, Get(*context.T, rpc.ServerCall, GetRequest, string) (GetResponse, string, error)
-pkg groups, type GroupServerMethods interface, GetPermissions(*context.T, rpc.ServerCall) (access.Permissions, string, error)
pkg groups, type GroupServerMethods interface, Relate(*context.T, rpc.ServerCall, map[string]struct{}, ApproximationType, string, map[string]struct{}) (map[string]struct{}, []Approximation, string, error)
pkg groups, type GroupServerMethods interface, Remove(*context.T, rpc.ServerCall, BlessingPatternChunk, string) error
-pkg groups, type GroupServerMethods interface, SetPermissions(*context.T, rpc.ServerCall, access.Permissions, string) error
+pkg groups, type GroupServerMethods interface, unexported methods
pkg groups, type GroupServerStub interface, Describe__() []rpc.InterfaceDesc
pkg groups, type GroupServerStub interface, unexported methods
pkg groups, type GroupServerStubMethods GroupServerMethods
pkg groups, var ApproximationTypeAll [...]ApproximationType
-pkg groups, var ErrCycleFound verror.IDAction
-pkg groups, var ErrExcessiveContention verror.IDAction
-pkg groups, var ErrNoBlessings verror.IDAction
+pkg groups, var ErrCycleFound unknown-type
+pkg groups, var ErrExcessiveContention unknown-type
+pkg groups, var ErrNoBlessings unknown-type
pkg groups, var GroupDesc rpc.InterfaceDesc
pkg groups, var GroupReaderDesc rpc.InterfaceDesc
diff --git a/services/groups/groups.vdl.go b/services/groups/groups.vdl.go
index 6112140..2bc0a48 100644
--- a/services/groups/groups.vdl.go
+++ b/services/groups/groups.vdl.go
@@ -63,6 +63,10 @@
return nil
}
+func (t *BlessingPatternChunkTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BlessingPatternChunk("")
+ return nil
+}
type GetRequest struct {
}
@@ -77,7 +81,6 @@
if err != nil {
return err
}
-
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -114,6 +117,10 @@
return nil
}
+func (t *GetRequestTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = GetRequest{}
+ return nil
+}
type GetResponse struct {
Entries map[BlessingPatternChunk]struct{}
@@ -129,32 +136,42 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Entries")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget4, err := fieldTarget3.StartSet(tt.NonOptional().Field(0).Type, len(m.Entries))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.Entries) == 0 {
+ var4 = true
}
- for key6 := range m.Entries {
- keyTarget5, err := setTarget4.StartKey()
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget5, err := fieldTarget3.StartSet(tt.NonOptional().Field(0).Type, len(m.Entries))
if err != nil {
return err
}
+ for key7 := range m.Entries {
+ keyTarget6, err := setTarget5.StartKey()
+ if err != nil {
+ return err
+ }
- if err := key6.FillVDLTarget(keyTarget5, tt.NonOptional().Field(0).Type.Key()); err != nil {
+ if err := key7.FillVDLTarget(keyTarget6, tt.NonOptional().Field(0).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget5.FinishKey(keyTarget6); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishSet(setTarget5); err != nil {
return err
}
- if err := setTarget4.FinishKey(keyTarget5); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishSet(setTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -201,6 +218,10 @@
return nil
}
+func (t *GetResponseTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = GetResponse{}
+ return nil
+}
// map[BlessingPatternChunk]struct{}
type __VDLTarget1_set struct {
@@ -236,6 +257,10 @@
return nil
}
+func (t *__VDLTarget1_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[BlessingPatternChunk]struct{}(nil)
+ return nil
+}
// ApproximationType defines the type of approximation desired when a Relate
// call encounters an error (inaccessible or undefined group in a blessing
@@ -316,11 +341,15 @@
case "Over":
*t.Value = 1
default:
- return fmt.Errorf("label %s not in enum v.io/v23/services/groups.ApproximationType", src)
+ return fmt.Errorf("label %s not in enum ApproximationType", src)
}
return nil
}
+func (t *ApproximationTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ApproximationTypeUnder
+ return nil
+}
// Approximation contains information about membership approximations made
// during a Relate call.
@@ -339,28 +368,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Reason")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Reason), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Reason == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Reason), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Details")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Details")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Details), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Details == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Details), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -410,15 +454,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroBlessingPatternChunk = BlessingPatternChunk("")
- __VDLZeroGetRequest = GetRequest{}
- __VDLZeroGetResponse = GetResponse{}
- __VDLZeroApproximationType = ApproximationTypeUnder
- __VDLZeroApproximation = Approximation{}
-)
+func (t *ApproximationTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Approximation{}
+ return nil
+}
//////////////////////////////////////////////////
// Error definitions
@@ -958,6 +997,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*BlessingPatternChunk)(nil))
diff --git a/services/logreader/.api b/services/logreader/.api
index 098c85e..7bd3cd7 100644
--- a/services/logreader/.api
+++ b/services/logreader/.api
@@ -5,6 +5,7 @@
pkg logreader, method (*LogEntry) MakeVDLTarget() vdl.Target
pkg logreader, method (*LogEntryTarget) FinishField(vdl.Target, vdl.Target) error
pkg logreader, method (*LogEntryTarget) FinishFields(vdl.FieldsTarget) error
+pkg logreader, method (*LogEntryTarget) FromZero(*vdl.Type) error
pkg logreader, method (*LogEntryTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg logreader, method (*LogEntryTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg logreader, method (*LogFileReadLogServerCallStub) Init(rpc.StreamServerCall)
@@ -19,22 +20,16 @@
pkg logreader, type LogFileClientMethods interface { ReadLog, Size }
pkg logreader, type LogFileClientMethods interface, ReadLog(*context.T, int64, int32, bool, ...rpc.CallOpt) (LogFileReadLogClientCall, error)
pkg logreader, type LogFileClientMethods interface, Size(*context.T, ...rpc.CallOpt) (int64, error)
-pkg logreader, type LogFileClientStub interface { ReadLog, Size }
pkg logreader, type LogFileClientStub interface, ReadLog(*context.T, int64, int32, bool, ...rpc.CallOpt) (LogFileReadLogClientCall, error)
pkg logreader, type LogFileClientStub interface, Size(*context.T, ...rpc.CallOpt) (int64, error)
+pkg logreader, type LogFileClientStub interface, unexported methods
pkg logreader, type LogFileReadLogClientCall interface { Finish, RecvStream }
pkg logreader, type LogFileReadLogClientCall interface, Finish() (int64, error)
pkg logreader, type LogFileReadLogClientCall interface, RecvStream() interface { Advance() bool;; Value() LogEntry;; Err() error;}
pkg logreader, type LogFileReadLogClientStream interface { RecvStream }
pkg logreader, type LogFileReadLogClientStream interface, RecvStream() interface { Advance() bool;; Value() LogEntry;; Err() error;}
-pkg logreader, type LogFileReadLogServerCall interface { GrantedBlessings, LocalEndpoint, RemoteEndpoint, Security, SendStream, Server, Suffix }
-pkg logreader, type LogFileReadLogServerCall interface, GrantedBlessings() security.Blessings
-pkg logreader, type LogFileReadLogServerCall interface, LocalEndpoint() naming.Endpoint
-pkg logreader, type LogFileReadLogServerCall interface, RemoteEndpoint() naming.Endpoint
-pkg logreader, type LogFileReadLogServerCall interface, Security() security.Call
pkg logreader, type LogFileReadLogServerCall interface, SendStream() interface { Send(item LogEntry) error;}
-pkg logreader, type LogFileReadLogServerCall interface, Server() Server
-pkg logreader, type LogFileReadLogServerCall interface, Suffix() string
+pkg logreader, type LogFileReadLogServerCall interface, unexported methods
pkg logreader, type LogFileReadLogServerCallStub struct
pkg logreader, type LogFileReadLogServerCallStub struct, embedded rpc.StreamServerCall
pkg logreader, type LogFileReadLogServerStream interface { SendStream }
diff --git a/services/logreader/logreader.vdl.go b/services/logreader/logreader.vdl.go
index fa16d7a..9a6d075 100644
--- a/services/logreader/logreader.vdl.go
+++ b/services/logreader/logreader.vdl.go
@@ -41,28 +41,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Position")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromInt(int64(m.Position), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Position == int64(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromInt(int64(m.Position), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Line")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Line")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Line), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Line == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Line), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -112,11 +127,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroLogEntry = LogEntry{}
-)
+func (t *LogEntryTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = LogEntry{}
+ return nil
+}
//////////////////////////////////////////////////
// Const definitions
@@ -435,6 +449,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*LogEntry)(nil))
diff --git a/services/mounttable/.api b/services/mounttable/.api
index da94747..5cc9a8f 100644
--- a/services/mounttable/.api
+++ b/services/mounttable/.api
@@ -8,27 +8,22 @@
pkg mounttable, method (*Tag) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg mounttable, method (*Tag) MakeVDLTarget() vdl.Target
pkg mounttable, method (*TagTarget) FromString(string, *vdl.Type) error
-pkg mounttable, type MountTableClientMethods interface { Delete, GetPermissions, Mount, ResolveStep, SetPermissions, Unmount }
+pkg mounttable, method (*TagTarget) FromZero(*vdl.Type) error
pkg mounttable, type MountTableClientMethods interface, Delete(*context.T, bool, ...rpc.CallOpt) error
-pkg mounttable, type MountTableClientMethods interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
pkg mounttable, type MountTableClientMethods interface, Mount(*context.T, string, uint32, naming.MountFlag, ...rpc.CallOpt) error
pkg mounttable, type MountTableClientMethods interface, ResolveStep(*context.T, ...rpc.CallOpt) (naming.MountEntry, error)
-pkg mounttable, type MountTableClientMethods interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
pkg mounttable, type MountTableClientMethods interface, Unmount(*context.T, string, ...rpc.CallOpt) error
-pkg mounttable, type MountTableClientStub interface { Delete, GetPermissions, Mount, ResolveStep, SetPermissions, Unmount }
+pkg mounttable, type MountTableClientMethods interface, unexported methods
pkg mounttable, type MountTableClientStub interface, Delete(*context.T, bool, ...rpc.CallOpt) error
-pkg mounttable, type MountTableClientStub interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
pkg mounttable, type MountTableClientStub interface, Mount(*context.T, string, uint32, naming.MountFlag, ...rpc.CallOpt) error
pkg mounttable, type MountTableClientStub interface, ResolveStep(*context.T, ...rpc.CallOpt) (naming.MountEntry, error)
-pkg mounttable, type MountTableClientStub interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
pkg mounttable, type MountTableClientStub interface, Unmount(*context.T, string, ...rpc.CallOpt) error
-pkg mounttable, type MountTableServerMethods interface { Delete, GetPermissions, Mount, ResolveStep, SetPermissions, Unmount }
+pkg mounttable, type MountTableClientStub interface, unexported methods
pkg mounttable, type MountTableServerMethods interface, Delete(*context.T, rpc.ServerCall, bool) error
-pkg mounttable, type MountTableServerMethods interface, GetPermissions(*context.T, rpc.ServerCall) (access.Permissions, string, error)
pkg mounttable, type MountTableServerMethods interface, Mount(*context.T, rpc.ServerCall, string, uint32, naming.MountFlag) error
pkg mounttable, type MountTableServerMethods interface, ResolveStep(*context.T, rpc.ServerCall) (naming.MountEntry, error)
-pkg mounttable, type MountTableServerMethods interface, SetPermissions(*context.T, rpc.ServerCall, access.Permissions, string) error
pkg mounttable, type MountTableServerMethods interface, Unmount(*context.T, rpc.ServerCall, string) error
+pkg mounttable, type MountTableServerMethods interface, unexported methods
pkg mounttable, type MountTableServerStub interface, Describe__() []rpc.InterfaceDesc
pkg mounttable, type MountTableServerStub interface, unexported methods
pkg mounttable, type MountTableServerStubMethods MountTableServerMethods
diff --git a/services/mounttable/mounttable.vdl.go b/services/mounttable/mounttable.vdl.go
index b58b1ba..c3fa8a5 100644
--- a/services/mounttable/mounttable.vdl.go
+++ b/services/mounttable/mounttable.vdl.go
@@ -65,11 +65,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroTag = Tag("")
-)
+func (t *TagTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Tag("")
+ return nil
+}
//////////////////////////////////////////////////
// Const definitions
@@ -419,6 +418,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*Tag)(nil))
diff --git a/services/permissions/.api b/services/permissions/.api
index 9cf3f2b..795c0c9 100644
--- a/services/permissions/.api
+++ b/services/permissions/.api
@@ -3,9 +3,9 @@
pkg permissions, type ObjectClientMethods interface { GetPermissions, SetPermissions }
pkg permissions, type ObjectClientMethods interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
pkg permissions, type ObjectClientMethods interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
-pkg permissions, type ObjectClientStub interface { GetPermissions, SetPermissions }
pkg permissions, type ObjectClientStub interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
pkg permissions, type ObjectClientStub interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
+pkg permissions, type ObjectClientStub interface, unexported methods
pkg permissions, type ObjectServerMethods interface { GetPermissions, SetPermissions }
pkg permissions, type ObjectServerMethods interface, GetPermissions(*context.T, rpc.ServerCall) (access.Permissions, string, error)
pkg permissions, type ObjectServerMethods interface, SetPermissions(*context.T, rpc.ServerCall, access.Permissions, string) error
diff --git a/services/permissions/permissions.vdl.go b/services/permissions/permissions.vdl.go
index 6e56440..1666c3e 100644
--- a/services/permissions/permissions.vdl.go
+++ b/services/permissions/permissions.vdl.go
@@ -299,6 +299,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
return struct{}{}
}
diff --git a/services/pprof/.api b/services/pprof/.api
index f828347..e5a7825 100644
--- a/services/pprof/.api
+++ b/services/pprof/.api
@@ -10,25 +10,19 @@
pkg pprof, type PProfClientMethods interface, Profile(*context.T, string, int32, ...rpc.CallOpt) (PProfProfileClientCall, error)
pkg pprof, type PProfClientMethods interface, Profiles(*context.T, ...rpc.CallOpt) ([]string, error)
pkg pprof, type PProfClientMethods interface, Symbol(*context.T, []uint64, ...rpc.CallOpt) ([]string, error)
-pkg pprof, type PProfClientStub interface { CmdLine, CpuProfile, Profile, Profiles, Symbol }
pkg pprof, type PProfClientStub interface, CmdLine(*context.T, ...rpc.CallOpt) ([]string, error)
pkg pprof, type PProfClientStub interface, CpuProfile(*context.T, int32, ...rpc.CallOpt) (PProfCpuProfileClientCall, error)
pkg pprof, type PProfClientStub interface, Profile(*context.T, string, int32, ...rpc.CallOpt) (PProfProfileClientCall, error)
pkg pprof, type PProfClientStub interface, Profiles(*context.T, ...rpc.CallOpt) ([]string, error)
pkg pprof, type PProfClientStub interface, Symbol(*context.T, []uint64, ...rpc.CallOpt) ([]string, error)
+pkg pprof, type PProfClientStub interface, unexported methods
pkg pprof, type PProfCpuProfileClientCall interface { Finish, RecvStream }
pkg pprof, type PProfCpuProfileClientCall interface, Finish() error
pkg pprof, type PProfCpuProfileClientCall interface, RecvStream() interface { Advance() bool;; Value() []byte;; Err() error;}
pkg pprof, type PProfCpuProfileClientStream interface { RecvStream }
pkg pprof, type PProfCpuProfileClientStream interface, RecvStream() interface { Advance() bool;; Value() []byte;; Err() error;}
-pkg pprof, type PProfCpuProfileServerCall interface { GrantedBlessings, LocalEndpoint, RemoteEndpoint, Security, SendStream, Server, Suffix }
-pkg pprof, type PProfCpuProfileServerCall interface, GrantedBlessings() security.Blessings
-pkg pprof, type PProfCpuProfileServerCall interface, LocalEndpoint() naming.Endpoint
-pkg pprof, type PProfCpuProfileServerCall interface, RemoteEndpoint() naming.Endpoint
-pkg pprof, type PProfCpuProfileServerCall interface, Security() security.Call
pkg pprof, type PProfCpuProfileServerCall interface, SendStream() interface { Send(item []byte) error;}
-pkg pprof, type PProfCpuProfileServerCall interface, Server() Server
-pkg pprof, type PProfCpuProfileServerCall interface, Suffix() string
+pkg pprof, type PProfCpuProfileServerCall interface, unexported methods
pkg pprof, type PProfCpuProfileServerCallStub struct
pkg pprof, type PProfCpuProfileServerCallStub struct, embedded rpc.StreamServerCall
pkg pprof, type PProfCpuProfileServerStream interface { SendStream }
@@ -38,14 +32,8 @@
pkg pprof, type PProfProfileClientCall interface, RecvStream() interface { Advance() bool;; Value() []byte;; Err() error;}
pkg pprof, type PProfProfileClientStream interface { RecvStream }
pkg pprof, type PProfProfileClientStream interface, RecvStream() interface { Advance() bool;; Value() []byte;; Err() error;}
-pkg pprof, type PProfProfileServerCall interface { GrantedBlessings, LocalEndpoint, RemoteEndpoint, Security, SendStream, Server, Suffix }
-pkg pprof, type PProfProfileServerCall interface, GrantedBlessings() security.Blessings
-pkg pprof, type PProfProfileServerCall interface, LocalEndpoint() naming.Endpoint
-pkg pprof, type PProfProfileServerCall interface, RemoteEndpoint() naming.Endpoint
-pkg pprof, type PProfProfileServerCall interface, Security() security.Call
pkg pprof, type PProfProfileServerCall interface, SendStream() interface { Send(item []byte) error;}
-pkg pprof, type PProfProfileServerCall interface, Server() Server
-pkg pprof, type PProfProfileServerCall interface, Suffix() string
+pkg pprof, type PProfProfileServerCall interface, unexported methods
pkg pprof, type PProfProfileServerCallStub struct
pkg pprof, type PProfProfileServerCallStub struct, embedded rpc.StreamServerCall
pkg pprof, type PProfProfileServerStream interface { SendStream }
diff --git a/services/pprof/pprof.vdl.go b/services/pprof/pprof.vdl.go
index 9b48917..9efeb4d 100644
--- a/services/pprof/pprof.vdl.go
+++ b/services/pprof/pprof.vdl.go
@@ -493,6 +493,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
return struct{}{}
}
diff --git a/services/repository/.api b/services/repository/.api
index 6f4ff8a..e92907c 100644
--- a/services/repository/.api
+++ b/services/repository/.api
@@ -12,70 +12,50 @@
pkg repository, method (*MediaInfo) MakeVDLTarget() vdl.Target
pkg repository, method (*MediaInfoTarget) FinishField(vdl.Target, vdl.Target) error
pkg repository, method (*MediaInfoTarget) FinishFields(vdl.FieldsTarget) error
+pkg repository, method (*MediaInfoTarget) FromZero(*vdl.Type) error
pkg repository, method (*MediaInfoTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg repository, method (*MediaInfoTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
-pkg repository, type ApplicationClientMethods interface { GetPermissions, Match, SetPermissions, TidyNow }
-pkg repository, type ApplicationClientMethods interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
pkg repository, type ApplicationClientMethods interface, Match(*context.T, []string, ...rpc.CallOpt) (application.Envelope, error)
-pkg repository, type ApplicationClientMethods interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
-pkg repository, type ApplicationClientMethods interface, TidyNow(*context.T, ...rpc.CallOpt) error
-pkg repository, type ApplicationClientStub interface { GetPermissions, Match, SetPermissions, TidyNow }
-pkg repository, type ApplicationClientStub interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
+pkg repository, type ApplicationClientMethods interface, unexported methods
pkg repository, type ApplicationClientStub interface, Match(*context.T, []string, ...rpc.CallOpt) (application.Envelope, error)
-pkg repository, type ApplicationClientStub interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
-pkg repository, type ApplicationClientStub interface, TidyNow(*context.T, ...rpc.CallOpt) error
-pkg repository, type ApplicationServerMethods interface { GetPermissions, Match, SetPermissions, TidyNow }
-pkg repository, type ApplicationServerMethods interface, GetPermissions(*context.T, rpc.ServerCall) (access.Permissions, string, error)
+pkg repository, type ApplicationClientStub interface, unexported methods
pkg repository, type ApplicationServerMethods interface, Match(*context.T, rpc.ServerCall, []string) (application.Envelope, error)
-pkg repository, type ApplicationServerMethods interface, SetPermissions(*context.T, rpc.ServerCall, access.Permissions, string) error
-pkg repository, type ApplicationServerMethods interface, TidyNow(*context.T, rpc.ServerCall) error
+pkg repository, type ApplicationServerMethods interface, unexported methods
pkg repository, type ApplicationServerStub interface, Describe__() []rpc.InterfaceDesc
pkg repository, type ApplicationServerStub interface, unexported methods
pkg repository, type ApplicationServerStubMethods ApplicationServerMethods
-pkg repository, type BinaryClientMethods interface { Create, Delete, Download, DownloadUrl, GetPermissions, SetPermissions, Stat, Upload }
pkg repository, type BinaryClientMethods interface, Create(*context.T, int32, MediaInfo, ...rpc.CallOpt) error
pkg repository, type BinaryClientMethods interface, Delete(*context.T, ...rpc.CallOpt) error
pkg repository, type BinaryClientMethods interface, Download(*context.T, int32, ...rpc.CallOpt) (BinaryDownloadClientCall, error)
pkg repository, type BinaryClientMethods interface, DownloadUrl(*context.T, ...rpc.CallOpt) (string, int64, error)
-pkg repository, type BinaryClientMethods interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
-pkg repository, type BinaryClientMethods interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
pkg repository, type BinaryClientMethods interface, Stat(*context.T, ...rpc.CallOpt) ([]binary.PartInfo, MediaInfo, error)
pkg repository, type BinaryClientMethods interface, Upload(*context.T, int32, ...rpc.CallOpt) (BinaryUploadClientCall, error)
-pkg repository, type BinaryClientStub interface { Create, Delete, Download, DownloadUrl, GetPermissions, SetPermissions, Stat, Upload }
+pkg repository, type BinaryClientMethods interface, unexported methods
pkg repository, type BinaryClientStub interface, Create(*context.T, int32, MediaInfo, ...rpc.CallOpt) error
pkg repository, type BinaryClientStub interface, Delete(*context.T, ...rpc.CallOpt) error
pkg repository, type BinaryClientStub interface, Download(*context.T, int32, ...rpc.CallOpt) (BinaryDownloadClientCall, error)
pkg repository, type BinaryClientStub interface, DownloadUrl(*context.T, ...rpc.CallOpt) (string, int64, error)
-pkg repository, type BinaryClientStub interface, GetPermissions(*context.T, ...rpc.CallOpt) (access.Permissions, string, error)
-pkg repository, type BinaryClientStub interface, SetPermissions(*context.T, access.Permissions, string, ...rpc.CallOpt) error
pkg repository, type BinaryClientStub interface, Stat(*context.T, ...rpc.CallOpt) ([]binary.PartInfo, MediaInfo, error)
pkg repository, type BinaryClientStub interface, Upload(*context.T, int32, ...rpc.CallOpt) (BinaryUploadClientCall, error)
+pkg repository, type BinaryClientStub interface, unexported methods
pkg repository, type BinaryDownloadClientCall interface { Finish, RecvStream }
pkg repository, type BinaryDownloadClientCall interface, Finish() error
pkg repository, type BinaryDownloadClientCall interface, RecvStream() interface { Advance() bool;; Value() []byte;; Err() error;}
pkg repository, type BinaryDownloadClientStream interface { RecvStream }
pkg repository, type BinaryDownloadClientStream interface, RecvStream() interface { Advance() bool;; Value() []byte;; Err() error;}
-pkg repository, type BinaryDownloadServerCall interface { GrantedBlessings, LocalEndpoint, RemoteEndpoint, Security, SendStream, Server, Suffix }
-pkg repository, type BinaryDownloadServerCall interface, GrantedBlessings() security.Blessings
-pkg repository, type BinaryDownloadServerCall interface, LocalEndpoint() naming.Endpoint
-pkg repository, type BinaryDownloadServerCall interface, RemoteEndpoint() naming.Endpoint
-pkg repository, type BinaryDownloadServerCall interface, Security() security.Call
pkg repository, type BinaryDownloadServerCall interface, SendStream() interface { Send(item []byte) error;}
-pkg repository, type BinaryDownloadServerCall interface, Server() Server
-pkg repository, type BinaryDownloadServerCall interface, Suffix() string
+pkg repository, type BinaryDownloadServerCall interface, unexported methods
pkg repository, type BinaryDownloadServerCallStub struct
pkg repository, type BinaryDownloadServerCallStub struct, embedded rpc.StreamServerCall
pkg repository, type BinaryDownloadServerStream interface { SendStream }
pkg repository, type BinaryDownloadServerStream interface, SendStream() interface { Send(item []byte) error;}
-pkg repository, type BinaryServerMethods interface { Create, Delete, Download, DownloadUrl, GetPermissions, SetPermissions, Stat, Upload }
pkg repository, type BinaryServerMethods interface, Create(*context.T, rpc.ServerCall, int32, MediaInfo) error
pkg repository, type BinaryServerMethods interface, Delete(*context.T, rpc.ServerCall) error
pkg repository, type BinaryServerMethods interface, Download(*context.T, BinaryDownloadServerCall, int32) error
pkg repository, type BinaryServerMethods interface, DownloadUrl(*context.T, rpc.ServerCall) (string, int64, error)
-pkg repository, type BinaryServerMethods interface, GetPermissions(*context.T, rpc.ServerCall) (access.Permissions, string, error)
-pkg repository, type BinaryServerMethods interface, SetPermissions(*context.T, rpc.ServerCall, access.Permissions, string) error
pkg repository, type BinaryServerMethods interface, Stat(*context.T, rpc.ServerCall) ([]binary.PartInfo, MediaInfo, error)
pkg repository, type BinaryServerMethods interface, Upload(*context.T, BinaryUploadServerCall, int32) error
+pkg repository, type BinaryServerMethods interface, unexported methods
pkg repository, type BinaryServerStub interface, Create(*context.T, rpc.ServerCall, int32, MediaInfo) error
pkg repository, type BinaryServerStub interface, Delete(*context.T, rpc.ServerCall) error
pkg repository, type BinaryServerStub interface, Describe__() []rpc.InterfaceDesc
@@ -96,14 +76,8 @@
pkg repository, type BinaryUploadClientCall interface, SendStream() interface { Send(item []byte) error;; Close() error;}
pkg repository, type BinaryUploadClientStream interface { SendStream }
pkg repository, type BinaryUploadClientStream interface, SendStream() interface { Send(item []byte) error;; Close() error;}
-pkg repository, type BinaryUploadServerCall interface { GrantedBlessings, LocalEndpoint, RecvStream, RemoteEndpoint, Security, Server, Suffix }
-pkg repository, type BinaryUploadServerCall interface, GrantedBlessings() security.Blessings
-pkg repository, type BinaryUploadServerCall interface, LocalEndpoint() naming.Endpoint
pkg repository, type BinaryUploadServerCall interface, RecvStream() interface { Advance() bool;; Value() []byte;; Err() error;}
-pkg repository, type BinaryUploadServerCall interface, RemoteEndpoint() naming.Endpoint
-pkg repository, type BinaryUploadServerCall interface, Security() security.Call
-pkg repository, type BinaryUploadServerCall interface, Server() Server
-pkg repository, type BinaryUploadServerCall interface, Suffix() string
+pkg repository, type BinaryUploadServerCall interface, unexported methods
pkg repository, type BinaryUploadServerCallStub struct
pkg repository, type BinaryUploadServerCallStub struct, embedded rpc.StreamServerCall
pkg repository, type BinaryUploadServerStream interface { RecvStream }
@@ -118,9 +92,9 @@
pkg repository, type ProfileClientMethods interface { Description, Label }
pkg repository, type ProfileClientMethods interface, Description(*context.T, ...rpc.CallOpt) (string, error)
pkg repository, type ProfileClientMethods interface, Label(*context.T, ...rpc.CallOpt) (string, error)
-pkg repository, type ProfileClientStub interface { Description, Label }
pkg repository, type ProfileClientStub interface, Description(*context.T, ...rpc.CallOpt) (string, error)
pkg repository, type ProfileClientStub interface, Label(*context.T, ...rpc.CallOpt) (string, error)
+pkg repository, type ProfileClientStub interface, unexported methods
pkg repository, type ProfileServerMethods interface { Description, Label }
pkg repository, type ProfileServerMethods interface, Description(*context.T, rpc.ServerCall) (string, error)
pkg repository, type ProfileServerMethods interface, Label(*context.T, rpc.ServerCall) (string, error)
diff --git a/services/repository/repository.vdl.go b/services/repository/repository.vdl.go
index fd0c532..fe92455 100644
--- a/services/repository/repository.vdl.go
+++ b/services/repository/repository.vdl.go
@@ -44,28 +44,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Type")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Type), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Type == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Type), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Encoding")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Encoding")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Encoding), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Encoding == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Encoding), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -115,11 +130,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroMediaInfo = MediaInfo{}
-)
+func (t *MediaInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MediaInfo{}
+ return nil
+}
//////////////////////////////////////////////////
// Interface definitions
@@ -1242,6 +1256,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*MediaInfo)(nil))
diff --git a/services/stats/.api b/services/stats/.api
index 001020d..fcc523f 100644
--- a/services/stats/.api
+++ b/services/stats/.api
@@ -1,21 +1,16 @@
pkg stats, func NewErrNoValue(*context.T, string) error
pkg stats, func StatsClient(string) StatsClientStub
pkg stats, func StatsServer(StatsServerMethods) StatsServerStub
-pkg stats, type StatsClientMethods interface { Value, WatchGlob }
pkg stats, type StatsClientMethods interface, Value(*context.T, ...rpc.CallOpt) (*vom.RawBytes, error)
-pkg stats, type StatsClientMethods interface, WatchGlob(*context.T, GlobRequest, ...rpc.CallOpt) (GlobWatcherWatchGlobClientCall, error)
-pkg stats, type StatsClientStub interface { Value, WatchGlob }
+pkg stats, type StatsClientMethods interface, unexported methods
pkg stats, type StatsClientStub interface, Value(*context.T, ...rpc.CallOpt) (*vom.RawBytes, error)
-pkg stats, type StatsClientStub interface, WatchGlob(*context.T, GlobRequest, ...rpc.CallOpt) (GlobWatcherWatchGlobClientCall, error)
-pkg stats, type StatsServerMethods interface { Value, WatchGlob }
+pkg stats, type StatsClientStub interface, unexported methods
pkg stats, type StatsServerMethods interface, Value(*context.T, rpc.ServerCall) (*vom.RawBytes, error)
-pkg stats, type StatsServerMethods interface, WatchGlob(*context.T, GlobWatcherWatchGlobServerCall, GlobRequest) error
-pkg stats, type StatsServerStub interface { Describe__, Value, WatchGlob }
+pkg stats, type StatsServerMethods interface, unexported methods
pkg stats, type StatsServerStub interface, Describe__() []rpc.InterfaceDesc
pkg stats, type StatsServerStub interface, Value(*context.T, rpc.ServerCall) (*vom.RawBytes, error)
-pkg stats, type StatsServerStub interface, WatchGlob(*context.T, *GlobWatcherWatchGlobServerCallStub, GlobRequest) error
-pkg stats, type StatsServerStubMethods interface { Value, WatchGlob }
+pkg stats, type StatsServerStub interface, unexported methods
pkg stats, type StatsServerStubMethods interface, Value(*context.T, rpc.ServerCall) (*vom.RawBytes, error)
-pkg stats, type StatsServerStubMethods interface, WatchGlob(*context.T, *GlobWatcherWatchGlobServerCallStub, GlobRequest) error
-pkg stats, var ErrNoValue verror.IDAction
+pkg stats, type StatsServerStubMethods interface, unexported methods
+pkg stats, var ErrNoValue unknown-type
pkg stats, var StatsDesc rpc.InterfaceDesc
diff --git a/services/stats/stats.vdl.go b/services/stats/stats.vdl.go
index c3a15da..67a66c3 100644
--- a/services/stats/stats.vdl.go
+++ b/services/stats/stats.vdl.go
@@ -201,6 +201,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Set error format strings.
i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrNoValue.ID), "{1:}{2:} object has no value, suffix: {3}")
diff --git a/services/syncbase/.api b/services/syncbase/.api
index 4192fce..aa7f183 100644
--- a/services/syncbase/.api
+++ b/services/syncbase/.api
@@ -55,26 +55,31 @@
pkg syncbase, method (*BatchInfo) MakeVDLTarget() vdl.Target
pkg syncbase, method (*BatchInfoTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*BatchInfoTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*BatchInfoTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*BatchInfoTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*BatchInfoTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*BatchOptions) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*BatchOptions) MakeVDLTarget() vdl.Target
pkg syncbase, method (*BatchOptionsTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*BatchOptionsTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*BatchOptionsTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*BatchOptionsTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*BatchOptionsTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*BatchSource) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*BatchSource) MakeVDLTarget() vdl.Target
pkg syncbase, method (*BatchSource) Set(string) error
pkg syncbase, method (*BatchSourceTarget) FromEnumLabel(string, *vdl.Type) error
+pkg syncbase, method (*BatchSourceTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*BlobFetchState) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*BlobFetchState) MakeVDLTarget() vdl.Target
pkg syncbase, method (*BlobFetchState) Set(string) error
pkg syncbase, method (*BlobFetchStateTarget) FromEnumLabel(string, *vdl.Type) error
+pkg syncbase, method (*BlobFetchStateTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*BlobFetchStatus) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*BlobFetchStatus) MakeVDLTarget() vdl.Target
pkg syncbase, method (*BlobFetchStatusTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*BlobFetchStatusTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*BlobFetchStatusTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*BlobFetchStatusTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*BlobFetchStatusTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*BlobManagerFetchBlobServerCallStub) Init(rpc.StreamServerCall)
@@ -86,22 +91,26 @@
pkg syncbase, method (*BlobRef) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*BlobRef) MakeVDLTarget() vdl.Target
pkg syncbase, method (*BlobRefTarget) FromString(string, *vdl.Type) error
+pkg syncbase, method (*BlobRefTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*CollectionRow) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*CollectionRow) MakeVDLTarget() vdl.Target
pkg syncbase, method (*CollectionRowTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*CollectionRowTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*CollectionRowTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*CollectionRowTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*CollectionRowTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*CollectionScanServerCallStub) Init(rpc.StreamServerCall)
pkg syncbase, method (*CollectionScanServerCallStub) SendStream() interface { Send(item KeyValue) error;}
pkg syncbase, method (*ConflictDataTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*ConflictDataTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*ConflictDataTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ConflictDataTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*ConflictDataTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*ConflictInfo) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*ConflictInfo) MakeVDLTarget() vdl.Target
pkg syncbase, method (*ConflictInfoTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*ConflictInfoTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*ConflictInfoTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ConflictInfoTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*ConflictInfoTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*ConflictManagerStartConflictResolverServerCallStub) Init(rpc.StreamServerCall)
@@ -111,12 +120,14 @@
pkg syncbase, method (*CrPolicy) MakeVDLTarget() vdl.Target
pkg syncbase, method (*CrPolicyTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*CrPolicyTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*CrPolicyTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*CrPolicyTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*CrPolicyTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*CrRule) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*CrRule) MakeVDLTarget() vdl.Target
pkg syncbase, method (*CrRuleTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*CrRuleTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*CrRuleTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*CrRuleTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*CrRuleTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*DatabaseExecServerCallStub) Init(rpc.StreamServerCall)
@@ -125,74 +136,87 @@
pkg syncbase, method (*DevModeUpdateVClockOpts) MakeVDLTarget() vdl.Target
pkg syncbase, method (*DevModeUpdateVClockOptsTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*DevModeUpdateVClockOptsTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*DevModeUpdateVClockOptsTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*DevModeUpdateVClockOptsTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*DevModeUpdateVClockOptsTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*KeyValue) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*KeyValue) MakeVDLTarget() vdl.Target
pkg syncbase, method (*KeyValueTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*KeyValueTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*KeyValueTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*KeyValueTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*KeyValueTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*OperationTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*OperationTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*OperationTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*OperationTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*OperationTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*PrefixPermissions) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*PrefixPermissions) MakeVDLTarget() vdl.Target
pkg syncbase, method (*PrefixPermissionsTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*PrefixPermissionsTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*PrefixPermissionsTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*PrefixPermissionsTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*PrefixPermissionsTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*ResolutionInfo) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*ResolutionInfo) MakeVDLTarget() vdl.Target
pkg syncbase, method (*ResolutionInfoTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*ResolutionInfoTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*ResolutionInfoTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ResolutionInfoTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*ResolutionInfoTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*ResolverType) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*ResolverType) MakeVDLTarget() vdl.Target
pkg syncbase, method (*ResolverType) Set(string) error
pkg syncbase, method (*ResolverTypeTarget) FromEnumLabel(string, *vdl.Type) error
+pkg syncbase, method (*ResolverTypeTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*RowInfo) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*RowInfo) MakeVDLTarget() vdl.Target
pkg syncbase, method (*RowInfoTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*RowInfoTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*RowInfoTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*RowInfoTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*RowInfoTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*RowOp) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*RowOp) MakeVDLTarget() vdl.Target
pkg syncbase, method (*RowOpTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*RowOpTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*RowOpTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*RowOpTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*RowOpTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*ScanOp) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*ScanOp) MakeVDLTarget() vdl.Target
pkg syncbase, method (*ScanOpTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*ScanOpTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*ScanOpTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ScanOpTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*ScanOpTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*SchemaMetadata) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*SchemaMetadata) MakeVDLTarget() vdl.Target
pkg syncbase, method (*SchemaMetadataTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*SchemaMetadataTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*SchemaMetadataTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*SchemaMetadataTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*SchemaMetadataTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*StoreChange) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*StoreChange) MakeVDLTarget() vdl.Target
pkg syncbase, method (*StoreChangeTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*StoreChangeTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*StoreChangeTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*StoreChangeTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*StoreChangeTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*SyncgroupMemberInfo) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*SyncgroupMemberInfo) MakeVDLTarget() vdl.Target
pkg syncbase, method (*SyncgroupMemberInfoTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*SyncgroupMemberInfoTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*SyncgroupMemberInfoTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*SyncgroupMemberInfoTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*SyncgroupMemberInfoTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*SyncgroupSpec) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*SyncgroupSpec) MakeVDLTarget() vdl.Target
pkg syncbase, method (*SyncgroupSpecTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*SyncgroupSpecTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*SyncgroupSpecTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*SyncgroupSpecTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*SyncgroupSpecTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*Value) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -201,12 +225,15 @@
pkg syncbase, method (*ValueSelection) MakeVDLTarget() vdl.Target
pkg syncbase, method (*ValueSelection) Set(string) error
pkg syncbase, method (*ValueSelectionTarget) FromEnumLabel(string, *vdl.Type) error
+pkg syncbase, method (*ValueSelectionTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ValueState) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*ValueState) MakeVDLTarget() vdl.Target
pkg syncbase, method (*ValueState) Set(string) error
pkg syncbase, method (*ValueStateTarget) FromEnumLabel(string, *vdl.Type) error
+pkg syncbase, method (*ValueStateTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ValueTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*ValueTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*ValueTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ValueTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*ValueTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (BatchSource) String() string
diff --git a/services/syncbase/nosql/.api b/services/syncbase/nosql/.api
new file mode 100644
index 0000000..0de087a
--- /dev/null
+++ b/services/syncbase/nosql/.api
@@ -0,0 +1,878 @@
+pkg nosql, const BatchSourceLocal BatchSource
+pkg nosql, const BatchSourceRemote BatchSource
+pkg nosql, const BlobFetchStateDone BlobFetchState
+pkg nosql, const BlobFetchStateFetching BlobFetchState
+pkg nosql, const BlobFetchStateLocating BlobFetchState
+pkg nosql, const BlobFetchStatePending BlobFetchState
+pkg nosql, const NullBlobRef BlobRef
+pkg nosql, const ResolverTypeAppResolves ResolverType
+pkg nosql, const ResolverTypeDefer ResolverType
+pkg nosql, const ResolverTypeLastWins ResolverType
+pkg nosql, const ValueSelectionLocal ValueSelection
+pkg nosql, const ValueSelectionOther ValueSelection
+pkg nosql, const ValueSelectionRemote ValueSelection
+pkg nosql, const ValueStateDeleted ValueState
+pkg nosql, const ValueStateExists ValueState
+pkg nosql, const ValueStateNoExists ValueState
+pkg nosql, const ValueStateUnknown ValueState
+pkg nosql, func BatchSourceFromString(string) (BatchSource, error)
+pkg nosql, func BlobFetchStateFromString(string) (BlobFetchState, error)
+pkg nosql, func BlobManagerClient(string) BlobManagerClientStub
+pkg nosql, func BlobManagerServer(BlobManagerServerMethods) BlobManagerServerStub
+pkg nosql, func ConflictManagerClient(string) ConflictManagerClientStub
+pkg nosql, func ConflictManagerServer(ConflictManagerServerMethods) ConflictManagerServerStub
+pkg nosql, func DatabaseClient(string) DatabaseClientStub
+pkg nosql, func DatabaseServer(DatabaseServerMethods) DatabaseServerStub
+pkg nosql, func DatabaseWatcherClient(string) DatabaseWatcherClientStub
+pkg nosql, func DatabaseWatcherServer(DatabaseWatcherServerMethods) DatabaseWatcherServerStub
+pkg nosql, func NewErrBlobNotCommitted(*context.T) error
+pkg nosql, func NewErrBoundToBatch(*context.T) error
+pkg nosql, func NewErrConcurrentBatch(*context.T) error
+pkg nosql, func NewErrNotBoundToBatch(*context.T) error
+pkg nosql, func NewErrReadOnlyBatch(*context.T) error
+pkg nosql, func NewErrSchemaVersionMismatch(*context.T) error
+pkg nosql, func NewErrSyncgroupJoinFailed(*context.T) error
+pkg nosql, func ResolverTypeFromString(string) (ResolverType, error)
+pkg nosql, func RowClient(string) RowClientStub
+pkg nosql, func RowServer(RowServerMethods) RowServerStub
+pkg nosql, func SchemaManagerClient(string) SchemaManagerClientStub
+pkg nosql, func SchemaManagerServer(SchemaManagerServerMethods) SchemaManagerServerStub
+pkg nosql, func SyncgroupManagerClient(string) SyncgroupManagerClientStub
+pkg nosql, func SyncgroupManagerServer(SyncgroupManagerServerMethods) SyncgroupManagerServerStub
+pkg nosql, func TableClient(string) TableClientStub
+pkg nosql, func TableServer(TableServerMethods) TableServerStub
+pkg nosql, func ValueSelectionFromString(string) (ValueSelection, error)
+pkg nosql, func ValueStateFromString(string) (ValueState, error)
+pkg nosql, method (*BatchInfo) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*BatchInfo) MakeVDLTarget() vdl.Target
+pkg nosql, method (*BatchInfoTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*BatchInfoTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*BatchInfoTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*BatchInfoTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*BatchInfoTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*BatchOptions) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*BatchOptions) MakeVDLTarget() vdl.Target
+pkg nosql, method (*BatchOptionsTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*BatchOptionsTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*BatchOptionsTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*BatchOptionsTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*BatchOptionsTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*BatchSource) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*BatchSource) MakeVDLTarget() vdl.Target
+pkg nosql, method (*BatchSource) Set(string) error
+pkg nosql, method (*BatchSourceTarget) FromEnumLabel(string, *vdl.Type) error
+pkg nosql, method (*BatchSourceTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*BlobFetchState) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*BlobFetchState) MakeVDLTarget() vdl.Target
+pkg nosql, method (*BlobFetchState) Set(string) error
+pkg nosql, method (*BlobFetchStateTarget) FromEnumLabel(string, *vdl.Type) error
+pkg nosql, method (*BlobFetchStateTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*BlobFetchStatus) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*BlobFetchStatus) MakeVDLTarget() vdl.Target
+pkg nosql, method (*BlobFetchStatusTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*BlobFetchStatusTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*BlobFetchStatusTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*BlobFetchStatusTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*BlobFetchStatusTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*BlobManagerFetchBlobServerCallStub) Init(rpc.StreamServerCall)
+pkg nosql, method (*BlobManagerFetchBlobServerCallStub) SendStream() interface { Send(item BlobFetchStatus) error;}
+pkg nosql, method (*BlobManagerGetBlobServerCallStub) Init(rpc.StreamServerCall)
+pkg nosql, method (*BlobManagerGetBlobServerCallStub) SendStream() interface { Send(item []byte) error;}
+pkg nosql, method (*BlobManagerPutBlobServerCallStub) Init(rpc.StreamServerCall)
+pkg nosql, method (*BlobManagerPutBlobServerCallStub) RecvStream() interface { Advance() bool; Value() []byte; Err() error;}
+pkg nosql, method (*BlobRef) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*BlobRef) MakeVDLTarget() vdl.Target
+pkg nosql, method (*BlobRefTarget) FromString(string, *vdl.Type) error
+pkg nosql, method (*BlobRefTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ConflictDataTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*ConflictDataTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*ConflictDataTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ConflictDataTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*ConflictDataTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*ConflictInfo) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*ConflictInfo) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ConflictInfoTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*ConflictInfoTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*ConflictInfoTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ConflictInfoTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*ConflictInfoTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*ConflictManagerStartConflictResolverServerCallStub) Init(rpc.StreamServerCall)
+pkg nosql, method (*ConflictManagerStartConflictResolverServerCallStub) RecvStream() interface { Advance() bool; Value() ResolutionInfo; Err() error;}
+pkg nosql, method (*ConflictManagerStartConflictResolverServerCallStub) SendStream() interface { Send(item ConflictInfo) error;}
+pkg nosql, method (*CrPolicy) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*CrPolicy) MakeVDLTarget() vdl.Target
+pkg nosql, method (*CrPolicyTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*CrPolicyTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*CrPolicyTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*CrPolicyTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*CrPolicyTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*CrRule) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*CrRule) MakeVDLTarget() vdl.Target
+pkg nosql, method (*CrRuleTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*CrRuleTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*CrRuleTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*CrRuleTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*CrRuleTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*DatabaseExecServerCallStub) Init(rpc.StreamServerCall)
+pkg nosql, method (*DatabaseExecServerCallStub) SendStream() interface { Send(item []*vom.RawBytes) error;}
+pkg nosql, method (*KeyValue) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*KeyValue) MakeVDLTarget() vdl.Target
+pkg nosql, method (*KeyValueTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*KeyValueTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*KeyValueTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*KeyValueTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*KeyValueTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*OperationTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*OperationTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*OperationTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*OperationTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*OperationTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*PrefixPermissions) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*PrefixPermissions) MakeVDLTarget() vdl.Target
+pkg nosql, method (*PrefixPermissionsTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*PrefixPermissionsTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*PrefixPermissionsTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*PrefixPermissionsTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*PrefixPermissionsTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*ResolutionInfo) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*ResolutionInfo) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ResolutionInfoTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*ResolutionInfoTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*ResolutionInfoTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ResolutionInfoTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*ResolutionInfoTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*ResolverType) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*ResolverType) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ResolverType) Set(string) error
+pkg nosql, method (*ResolverTypeTarget) FromEnumLabel(string, *vdl.Type) error
+pkg nosql, method (*ResolverTypeTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*RowInfo) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*RowInfo) MakeVDLTarget() vdl.Target
+pkg nosql, method (*RowInfoTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*RowInfoTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*RowInfoTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*RowInfoTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*RowInfoTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*RowOp) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*RowOp) MakeVDLTarget() vdl.Target
+pkg nosql, method (*RowOpTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*RowOpTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*RowOpTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*RowOpTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*RowOpTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*ScanOp) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*ScanOp) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ScanOpTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*ScanOpTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*ScanOpTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ScanOpTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*ScanOpTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*SchemaMetadata) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*SchemaMetadata) MakeVDLTarget() vdl.Target
+pkg nosql, method (*SchemaMetadataTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*SchemaMetadataTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*SchemaMetadataTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*SchemaMetadataTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*SchemaMetadataTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*StoreChange) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*StoreChange) MakeVDLTarget() vdl.Target
+pkg nosql, method (*StoreChangeTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*StoreChangeTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*StoreChangeTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*StoreChangeTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*StoreChangeTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*SyncgroupMemberInfo) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*SyncgroupMemberInfo) MakeVDLTarget() vdl.Target
+pkg nosql, method (*SyncgroupMemberInfoTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*SyncgroupMemberInfoTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*SyncgroupMemberInfoTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*SyncgroupMemberInfoTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*SyncgroupMemberInfoTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*SyncgroupSpec) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*SyncgroupSpec) MakeVDLTarget() vdl.Target
+pkg nosql, method (*SyncgroupSpecTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*SyncgroupSpecTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*SyncgroupSpecTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*SyncgroupSpecTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*SyncgroupSpecTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*TableRow) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*TableRow) MakeVDLTarget() vdl.Target
+pkg nosql, method (*TableRowTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*TableRowTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*TableRowTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*TableRowTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*TableRowTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*TableScanServerCallStub) Init(rpc.StreamServerCall)
+pkg nosql, method (*TableScanServerCallStub) SendStream() interface { Send(item KeyValue) error;}
+pkg nosql, method (*Value) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*Value) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ValueSelection) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*ValueSelection) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ValueSelection) Set(string) error
+pkg nosql, method (*ValueSelectionTarget) FromEnumLabel(string, *vdl.Type) error
+pkg nosql, method (*ValueSelectionTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ValueState) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*ValueState) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ValueState) Set(string) error
+pkg nosql, method (*ValueStateTarget) FromEnumLabel(string, *vdl.Type) error
+pkg nosql, method (*ValueStateTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ValueTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*ValueTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*ValueTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ValueTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*ValueTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (BatchSource) String() string
+pkg nosql, method (BlobFetchState) String() string
+pkg nosql, method (ConflictDataBatch) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (ConflictDataBatch) Index() int
+pkg nosql, method (ConflictDataBatch) Interface() interface{}
+pkg nosql, method (ConflictDataBatch) MakeVDLTarget() vdl.Target
+pkg nosql, method (ConflictDataBatch) Name() string
+pkg nosql, method (ConflictDataRow) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (ConflictDataRow) Index() int
+pkg nosql, method (ConflictDataRow) Interface() interface{}
+pkg nosql, method (ConflictDataRow) MakeVDLTarget() vdl.Target
+pkg nosql, method (ConflictDataRow) Name() string
+pkg nosql, method (OperationRead) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (OperationRead) Index() int
+pkg nosql, method (OperationRead) Interface() interface{}
+pkg nosql, method (OperationRead) MakeVDLTarget() vdl.Target
+pkg nosql, method (OperationRead) Name() string
+pkg nosql, method (OperationScan) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (OperationScan) Index() int
+pkg nosql, method (OperationScan) Interface() interface{}
+pkg nosql, method (OperationScan) MakeVDLTarget() vdl.Target
+pkg nosql, method (OperationScan) Name() string
+pkg nosql, method (OperationWrite) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (OperationWrite) Index() int
+pkg nosql, method (OperationWrite) Interface() interface{}
+pkg nosql, method (OperationWrite) MakeVDLTarget() vdl.Target
+pkg nosql, method (OperationWrite) Name() string
+pkg nosql, method (ResolverType) String() string
+pkg nosql, method (ValueSelection) String() string
+pkg nosql, method (ValueState) String() string
+pkg nosql, type BatchInfo struct
+pkg nosql, type BatchInfo struct, Hint string
+pkg nosql, type BatchInfo struct, Id uint64
+pkg nosql, type BatchInfo struct, Source BatchSource
+pkg nosql, type BatchInfoTarget struct
+pkg nosql, type BatchInfoTarget struct, Value *BatchInfo
+pkg nosql, type BatchInfoTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type BatchInfoTarget struct, embedded vdl.TargetBase
+pkg nosql, type BatchOptions struct
+pkg nosql, type BatchOptions struct, Hint string
+pkg nosql, type BatchOptions struct, ReadOnly bool
+pkg nosql, type BatchOptionsTarget struct
+pkg nosql, type BatchOptionsTarget struct, Value *BatchOptions
+pkg nosql, type BatchOptionsTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type BatchOptionsTarget struct, embedded vdl.TargetBase
+pkg nosql, type BatchSource int
+pkg nosql, type BatchSourceTarget struct
+pkg nosql, type BatchSourceTarget struct, Value *BatchSource
+pkg nosql, type BatchSourceTarget struct, embedded vdl.TargetBase
+pkg nosql, type BlobFetchState int
+pkg nosql, type BlobFetchStateTarget struct
+pkg nosql, type BlobFetchStateTarget struct, Value *BlobFetchState
+pkg nosql, type BlobFetchStateTarget struct, embedded vdl.TargetBase
+pkg nosql, type BlobFetchStatus struct
+pkg nosql, type BlobFetchStatus struct, Received int64
+pkg nosql, type BlobFetchStatus struct, State BlobFetchState
+pkg nosql, type BlobFetchStatus struct, Total int64
+pkg nosql, type BlobFetchStatusTarget struct
+pkg nosql, type BlobFetchStatusTarget struct, Value *BlobFetchStatus
+pkg nosql, type BlobFetchStatusTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type BlobFetchStatusTarget struct, embedded vdl.TargetBase
+pkg nosql, type BlobManagerClientMethods interface { CommitBlob, CreateBlob, DeleteBlob, FetchBlob, GetBlob, GetBlobSize, KeepBlob, PinBlob, PutBlob, UnpinBlob }
+pkg nosql, type BlobManagerClientMethods interface, CommitBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type BlobManagerClientMethods interface, CreateBlob(*context.T, ...rpc.CallOpt) (BlobRef, error)
+pkg nosql, type BlobManagerClientMethods interface, DeleteBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type BlobManagerClientMethods interface, FetchBlob(*context.T, BlobRef, uint64, ...rpc.CallOpt) (BlobManagerFetchBlobClientCall, error)
+pkg nosql, type BlobManagerClientMethods interface, GetBlob(*context.T, BlobRef, int64, ...rpc.CallOpt) (BlobManagerGetBlobClientCall, error)
+pkg nosql, type BlobManagerClientMethods interface, GetBlobSize(*context.T, BlobRef, ...rpc.CallOpt) (int64, error)
+pkg nosql, type BlobManagerClientMethods interface, KeepBlob(*context.T, BlobRef, uint64, ...rpc.CallOpt) error
+pkg nosql, type BlobManagerClientMethods interface, PinBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type BlobManagerClientMethods interface, PutBlob(*context.T, BlobRef, ...rpc.CallOpt) (BlobManagerPutBlobClientCall, error)
+pkg nosql, type BlobManagerClientMethods interface, UnpinBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type BlobManagerClientStub interface, CommitBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type BlobManagerClientStub interface, CreateBlob(*context.T, ...rpc.CallOpt) (BlobRef, error)
+pkg nosql, type BlobManagerClientStub interface, DeleteBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type BlobManagerClientStub interface, FetchBlob(*context.T, BlobRef, uint64, ...rpc.CallOpt) (BlobManagerFetchBlobClientCall, error)
+pkg nosql, type BlobManagerClientStub interface, GetBlob(*context.T, BlobRef, int64, ...rpc.CallOpt) (BlobManagerGetBlobClientCall, error)
+pkg nosql, type BlobManagerClientStub interface, GetBlobSize(*context.T, BlobRef, ...rpc.CallOpt) (int64, error)
+pkg nosql, type BlobManagerClientStub interface, KeepBlob(*context.T, BlobRef, uint64, ...rpc.CallOpt) error
+pkg nosql, type BlobManagerClientStub interface, PinBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type BlobManagerClientStub interface, PutBlob(*context.T, BlobRef, ...rpc.CallOpt) (BlobManagerPutBlobClientCall, error)
+pkg nosql, type BlobManagerClientStub interface, UnpinBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type BlobManagerClientStub interface, unexported methods
+pkg nosql, type BlobManagerFetchBlobClientCall interface { Finish, RecvStream }
+pkg nosql, type BlobManagerFetchBlobClientCall interface, Finish() error
+pkg nosql, type BlobManagerFetchBlobClientCall interface, RecvStream() interface { Advance() bool;; Value() BlobFetchStatus;; Err() error;}
+pkg nosql, type BlobManagerFetchBlobClientStream interface { RecvStream }
+pkg nosql, type BlobManagerFetchBlobClientStream interface, RecvStream() interface { Advance() bool;; Value() BlobFetchStatus;; Err() error;}
+pkg nosql, type BlobManagerFetchBlobServerCall interface, SendStream() interface { Send(item BlobFetchStatus) error;}
+pkg nosql, type BlobManagerFetchBlobServerCall interface, unexported methods
+pkg nosql, type BlobManagerFetchBlobServerCallStub struct
+pkg nosql, type BlobManagerFetchBlobServerCallStub struct, embedded rpc.StreamServerCall
+pkg nosql, type BlobManagerFetchBlobServerStream interface { SendStream }
+pkg nosql, type BlobManagerFetchBlobServerStream interface, SendStream() interface { Send(item BlobFetchStatus) error;}
+pkg nosql, type BlobManagerGetBlobClientCall interface { Finish, RecvStream }
+pkg nosql, type BlobManagerGetBlobClientCall interface, Finish() error
+pkg nosql, type BlobManagerGetBlobClientCall interface, RecvStream() interface { Advance() bool;; Value() []byte;; Err() error;}
+pkg nosql, type BlobManagerGetBlobClientStream interface { RecvStream }
+pkg nosql, type BlobManagerGetBlobClientStream interface, RecvStream() interface { Advance() bool;; Value() []byte;; Err() error;}
+pkg nosql, type BlobManagerGetBlobServerCall interface, SendStream() interface { Send(item []byte) error;}
+pkg nosql, type BlobManagerGetBlobServerCall interface, unexported methods
+pkg nosql, type BlobManagerGetBlobServerCallStub struct
+pkg nosql, type BlobManagerGetBlobServerCallStub struct, embedded rpc.StreamServerCall
+pkg nosql, type BlobManagerGetBlobServerStream interface { SendStream }
+pkg nosql, type BlobManagerGetBlobServerStream interface, SendStream() interface { Send(item []byte) error;}
+pkg nosql, type BlobManagerPutBlobClientCall interface { Finish, SendStream }
+pkg nosql, type BlobManagerPutBlobClientCall interface, Finish() error
+pkg nosql, type BlobManagerPutBlobClientCall interface, SendStream() interface { Send(item []byte) error;; Close() error;}
+pkg nosql, type BlobManagerPutBlobClientStream interface { SendStream }
+pkg nosql, type BlobManagerPutBlobClientStream interface, SendStream() interface { Send(item []byte) error;; Close() error;}
+pkg nosql, type BlobManagerPutBlobServerCall interface, RecvStream() interface { Advance() bool;; Value() []byte;; Err() error;}
+pkg nosql, type BlobManagerPutBlobServerCall interface, unexported methods
+pkg nosql, type BlobManagerPutBlobServerCallStub struct
+pkg nosql, type BlobManagerPutBlobServerCallStub struct, embedded rpc.StreamServerCall
+pkg nosql, type BlobManagerPutBlobServerStream interface { RecvStream }
+pkg nosql, type BlobManagerPutBlobServerStream interface, RecvStream() interface { Advance() bool;; Value() []byte;; Err() error;}
+pkg nosql, type BlobManagerServerMethods interface { CommitBlob, CreateBlob, DeleteBlob, FetchBlob, GetBlob, GetBlobSize, KeepBlob, PinBlob, PutBlob, UnpinBlob }
+pkg nosql, type BlobManagerServerMethods interface, CommitBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type BlobManagerServerMethods interface, CreateBlob(*context.T, rpc.ServerCall) (BlobRef, error)
+pkg nosql, type BlobManagerServerMethods interface, DeleteBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type BlobManagerServerMethods interface, FetchBlob(*context.T, BlobManagerFetchBlobServerCall, BlobRef, uint64) error
+pkg nosql, type BlobManagerServerMethods interface, GetBlob(*context.T, BlobManagerGetBlobServerCall, BlobRef, int64) error
+pkg nosql, type BlobManagerServerMethods interface, GetBlobSize(*context.T, rpc.ServerCall, BlobRef) (int64, error)
+pkg nosql, type BlobManagerServerMethods interface, KeepBlob(*context.T, rpc.ServerCall, BlobRef, uint64) error
+pkg nosql, type BlobManagerServerMethods interface, PinBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type BlobManagerServerMethods interface, PutBlob(*context.T, BlobManagerPutBlobServerCall, BlobRef) error
+pkg nosql, type BlobManagerServerMethods interface, UnpinBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type BlobManagerServerStub interface { CommitBlob, CreateBlob, DeleteBlob, Describe__, FetchBlob, GetBlob, GetBlobSize, KeepBlob, PinBlob, PutBlob, UnpinBlob }
+pkg nosql, type BlobManagerServerStub interface, CommitBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type BlobManagerServerStub interface, CreateBlob(*context.T, rpc.ServerCall) (BlobRef, error)
+pkg nosql, type BlobManagerServerStub interface, DeleteBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type BlobManagerServerStub interface, Describe__() []rpc.InterfaceDesc
+pkg nosql, type BlobManagerServerStub interface, FetchBlob(*context.T, *BlobManagerFetchBlobServerCallStub, BlobRef, uint64) error
+pkg nosql, type BlobManagerServerStub interface, GetBlob(*context.T, *BlobManagerGetBlobServerCallStub, BlobRef, int64) error
+pkg nosql, type BlobManagerServerStub interface, GetBlobSize(*context.T, rpc.ServerCall, BlobRef) (int64, error)
+pkg nosql, type BlobManagerServerStub interface, KeepBlob(*context.T, rpc.ServerCall, BlobRef, uint64) error
+pkg nosql, type BlobManagerServerStub interface, PinBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type BlobManagerServerStub interface, PutBlob(*context.T, *BlobManagerPutBlobServerCallStub, BlobRef) error
+pkg nosql, type BlobManagerServerStub interface, UnpinBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type BlobManagerServerStubMethods interface { CommitBlob, CreateBlob, DeleteBlob, FetchBlob, GetBlob, GetBlobSize, KeepBlob, PinBlob, PutBlob, UnpinBlob }
+pkg nosql, type BlobManagerServerStubMethods interface, CommitBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type BlobManagerServerStubMethods interface, CreateBlob(*context.T, rpc.ServerCall) (BlobRef, error)
+pkg nosql, type BlobManagerServerStubMethods interface, DeleteBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type BlobManagerServerStubMethods interface, FetchBlob(*context.T, *BlobManagerFetchBlobServerCallStub, BlobRef, uint64) error
+pkg nosql, type BlobManagerServerStubMethods interface, GetBlob(*context.T, *BlobManagerGetBlobServerCallStub, BlobRef, int64) error
+pkg nosql, type BlobManagerServerStubMethods interface, GetBlobSize(*context.T, rpc.ServerCall, BlobRef) (int64, error)
+pkg nosql, type BlobManagerServerStubMethods interface, KeepBlob(*context.T, rpc.ServerCall, BlobRef, uint64) error
+pkg nosql, type BlobManagerServerStubMethods interface, PinBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type BlobManagerServerStubMethods interface, PutBlob(*context.T, *BlobManagerPutBlobServerCallStub, BlobRef) error
+pkg nosql, type BlobManagerServerStubMethods interface, UnpinBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type BlobRef string
+pkg nosql, type BlobRefTarget struct
+pkg nosql, type BlobRefTarget struct, Value *BlobRef
+pkg nosql, type BlobRefTarget struct, embedded vdl.TargetBase
+pkg nosql, type ConflictData interface, FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, type ConflictData interface, Index() int
+pkg nosql, type ConflictData interface, Interface() interface{}
+pkg nosql, type ConflictData interface, Name() string
+pkg nosql, type ConflictData interface, unexported methods
+pkg nosql, type ConflictDataBatch struct
+pkg nosql, type ConflictDataBatch struct, Value BatchInfo
+pkg nosql, type ConflictDataRow struct
+pkg nosql, type ConflictDataRow struct, Value RowInfo
+pkg nosql, type ConflictDataTarget struct
+pkg nosql, type ConflictDataTarget struct, Value *ConflictData
+pkg nosql, type ConflictDataTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type ConflictDataTarget struct, embedded vdl.TargetBase
+pkg nosql, type ConflictInfo struct
+pkg nosql, type ConflictInfo struct, Continued bool
+pkg nosql, type ConflictInfo struct, Data ConflictData
+pkg nosql, type ConflictInfoTarget struct
+pkg nosql, type ConflictInfoTarget struct, Value *ConflictInfo
+pkg nosql, type ConflictInfoTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type ConflictInfoTarget struct, embedded vdl.TargetBase
+pkg nosql, type ConflictManagerClientMethods interface { StartConflictResolver }
+pkg nosql, type ConflictManagerClientMethods interface, StartConflictResolver(*context.T, ...rpc.CallOpt) (ConflictManagerStartConflictResolverClientCall, error)
+pkg nosql, type ConflictManagerClientStub interface, StartConflictResolver(*context.T, ...rpc.CallOpt) (ConflictManagerStartConflictResolverClientCall, error)
+pkg nosql, type ConflictManagerClientStub interface, unexported methods
+pkg nosql, type ConflictManagerServerMethods interface { StartConflictResolver }
+pkg nosql, type ConflictManagerServerMethods interface, StartConflictResolver(*context.T, ConflictManagerStartConflictResolverServerCall) error
+pkg nosql, type ConflictManagerServerStub interface { Describe__, StartConflictResolver }
+pkg nosql, type ConflictManagerServerStub interface, Describe__() []rpc.InterfaceDesc
+pkg nosql, type ConflictManagerServerStub interface, StartConflictResolver(*context.T, *ConflictManagerStartConflictResolverServerCallStub) error
+pkg nosql, type ConflictManagerServerStubMethods interface { StartConflictResolver }
+pkg nosql, type ConflictManagerServerStubMethods interface, StartConflictResolver(*context.T, *ConflictManagerStartConflictResolverServerCallStub) error
+pkg nosql, type ConflictManagerStartConflictResolverClientCall interface { Finish, RecvStream, SendStream }
+pkg nosql, type ConflictManagerStartConflictResolverClientCall interface, Finish() error
+pkg nosql, type ConflictManagerStartConflictResolverClientCall interface, RecvStream() interface { Advance() bool;; Value() ConflictInfo;; Err() error;}
+pkg nosql, type ConflictManagerStartConflictResolverClientCall interface, SendStream() interface { Send(item ResolutionInfo) error;; Close() error;}
+pkg nosql, type ConflictManagerStartConflictResolverClientStream interface { RecvStream, SendStream }
+pkg nosql, type ConflictManagerStartConflictResolverClientStream interface, RecvStream() interface { Advance() bool;; Value() ConflictInfo;; Err() error;}
+pkg nosql, type ConflictManagerStartConflictResolverClientStream interface, SendStream() interface { Send(item ResolutionInfo) error;; Close() error;}
+pkg nosql, type ConflictManagerStartConflictResolverServerCall interface, RecvStream() interface { Advance() bool;; Value() ResolutionInfo;; Err() error;}
+pkg nosql, type ConflictManagerStartConflictResolverServerCall interface, SendStream() interface { Send(item ConflictInfo) error;}
+pkg nosql, type ConflictManagerStartConflictResolverServerCall interface, unexported methods
+pkg nosql, type ConflictManagerStartConflictResolverServerCallStub struct
+pkg nosql, type ConflictManagerStartConflictResolverServerCallStub struct, embedded rpc.StreamServerCall
+pkg nosql, type ConflictManagerStartConflictResolverServerStream interface { RecvStream, SendStream }
+pkg nosql, type ConflictManagerStartConflictResolverServerStream interface, RecvStream() interface { Advance() bool;; Value() ResolutionInfo;; Err() error;}
+pkg nosql, type ConflictManagerStartConflictResolverServerStream interface, SendStream() interface { Send(item ConflictInfo) error;}
+pkg nosql, type CrPolicy struct
+pkg nosql, type CrPolicy struct, Rules []CrRule
+pkg nosql, type CrPolicyTarget struct
+pkg nosql, type CrPolicyTarget struct, Value *CrPolicy
+pkg nosql, type CrPolicyTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type CrPolicyTarget struct, embedded vdl.TargetBase
+pkg nosql, type CrRule struct
+pkg nosql, type CrRule struct, KeyPrefix string
+pkg nosql, type CrRule struct, Resolver ResolverType
+pkg nosql, type CrRule struct, TableName string
+pkg nosql, type CrRule struct, Type string
+pkg nosql, type CrRuleTarget struct
+pkg nosql, type CrRuleTarget struct, Value *CrRule
+pkg nosql, type CrRuleTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type CrRuleTarget struct, embedded vdl.TargetBase
+pkg nosql, type DatabaseClientMethods interface, Abort(*context.T, int32, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, BeginBatch(*context.T, int32, BatchOptions, ...rpc.CallOpt) (string, error)
+pkg nosql, type DatabaseClientMethods interface, Commit(*context.T, int32, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, CommitBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, Create(*context.T, *SchemaMetadata, access.Permissions, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, CreateBlob(*context.T, ...rpc.CallOpt) (BlobRef, error)
+pkg nosql, type DatabaseClientMethods interface, CreateSyncgroup(*context.T, string, SyncgroupSpec, SyncgroupMemberInfo, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, DeleteBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, Destroy(*context.T, int32, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, DestroySyncgroup(*context.T, string, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, EjectFromSyncgroup(*context.T, string, string, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, Exec(*context.T, int32, string, []*vom.RawBytes, ...rpc.CallOpt) (DatabaseExecClientCall, error)
+pkg nosql, type DatabaseClientMethods interface, Exists(*context.T, int32, ...rpc.CallOpt) (bool, error)
+pkg nosql, type DatabaseClientMethods interface, FetchBlob(*context.T, BlobRef, uint64, ...rpc.CallOpt) (BlobManagerFetchBlobClientCall, error)
+pkg nosql, type DatabaseClientMethods interface, GetBlob(*context.T, BlobRef, int64, ...rpc.CallOpt) (BlobManagerGetBlobClientCall, error)
+pkg nosql, type DatabaseClientMethods interface, GetBlobSize(*context.T, BlobRef, ...rpc.CallOpt) (int64, error)
+pkg nosql, type DatabaseClientMethods interface, GetResumeMarker(*context.T, ...rpc.CallOpt) (watch.ResumeMarker, error)
+pkg nosql, type DatabaseClientMethods interface, GetSchemaMetadata(*context.T, ...rpc.CallOpt) (SchemaMetadata, error)
+pkg nosql, type DatabaseClientMethods interface, GetSyncgroupMembers(*context.T, string, ...rpc.CallOpt) (map[string]SyncgroupMemberInfo, error)
+pkg nosql, type DatabaseClientMethods interface, GetSyncgroupNames(*context.T, ...rpc.CallOpt) ([]string, error)
+pkg nosql, type DatabaseClientMethods interface, GetSyncgroupSpec(*context.T, string, ...rpc.CallOpt) (SyncgroupSpec, string, error)
+pkg nosql, type DatabaseClientMethods interface, JoinSyncgroup(*context.T, string, SyncgroupMemberInfo, ...rpc.CallOpt) (SyncgroupSpec, error)
+pkg nosql, type DatabaseClientMethods interface, KeepBlob(*context.T, BlobRef, uint64, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, LeaveSyncgroup(*context.T, string, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, ListTables(*context.T, ...rpc.CallOpt) ([]string, error)
+pkg nosql, type DatabaseClientMethods interface, PauseSync(*context.T, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, PinBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, PutBlob(*context.T, BlobRef, ...rpc.CallOpt) (BlobManagerPutBlobClientCall, error)
+pkg nosql, type DatabaseClientMethods interface, ResumeSync(*context.T, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, SetSchemaMetadata(*context.T, SchemaMetadata, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, SetSyncgroupSpec(*context.T, string, SyncgroupSpec, string, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, StartConflictResolver(*context.T, ...rpc.CallOpt) (ConflictManagerStartConflictResolverClientCall, error)
+pkg nosql, type DatabaseClientMethods interface, UnpinBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientMethods interface, unexported methods
+pkg nosql, type DatabaseClientStub interface, Abort(*context.T, int32, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, BeginBatch(*context.T, int32, BatchOptions, ...rpc.CallOpt) (string, error)
+pkg nosql, type DatabaseClientStub interface, Commit(*context.T, int32, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, CommitBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, Create(*context.T, *SchemaMetadata, access.Permissions, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, CreateBlob(*context.T, ...rpc.CallOpt) (BlobRef, error)
+pkg nosql, type DatabaseClientStub interface, CreateSyncgroup(*context.T, string, SyncgroupSpec, SyncgroupMemberInfo, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, DeleteBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, Destroy(*context.T, int32, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, DestroySyncgroup(*context.T, string, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, EjectFromSyncgroup(*context.T, string, string, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, Exec(*context.T, int32, string, []*vom.RawBytes, ...rpc.CallOpt) (DatabaseExecClientCall, error)
+pkg nosql, type DatabaseClientStub interface, Exists(*context.T, int32, ...rpc.CallOpt) (bool, error)
+pkg nosql, type DatabaseClientStub interface, FetchBlob(*context.T, BlobRef, uint64, ...rpc.CallOpt) (BlobManagerFetchBlobClientCall, error)
+pkg nosql, type DatabaseClientStub interface, GetBlob(*context.T, BlobRef, int64, ...rpc.CallOpt) (BlobManagerGetBlobClientCall, error)
+pkg nosql, type DatabaseClientStub interface, GetBlobSize(*context.T, BlobRef, ...rpc.CallOpt) (int64, error)
+pkg nosql, type DatabaseClientStub interface, GetResumeMarker(*context.T, ...rpc.CallOpt) (watch.ResumeMarker, error)
+pkg nosql, type DatabaseClientStub interface, GetSchemaMetadata(*context.T, ...rpc.CallOpt) (SchemaMetadata, error)
+pkg nosql, type DatabaseClientStub interface, GetSyncgroupMembers(*context.T, string, ...rpc.CallOpt) (map[string]SyncgroupMemberInfo, error)
+pkg nosql, type DatabaseClientStub interface, GetSyncgroupNames(*context.T, ...rpc.CallOpt) ([]string, error)
+pkg nosql, type DatabaseClientStub interface, GetSyncgroupSpec(*context.T, string, ...rpc.CallOpt) (SyncgroupSpec, string, error)
+pkg nosql, type DatabaseClientStub interface, JoinSyncgroup(*context.T, string, SyncgroupMemberInfo, ...rpc.CallOpt) (SyncgroupSpec, error)
+pkg nosql, type DatabaseClientStub interface, KeepBlob(*context.T, BlobRef, uint64, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, LeaveSyncgroup(*context.T, string, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, ListTables(*context.T, ...rpc.CallOpt) ([]string, error)
+pkg nosql, type DatabaseClientStub interface, PauseSync(*context.T, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, PinBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, PutBlob(*context.T, BlobRef, ...rpc.CallOpt) (BlobManagerPutBlobClientCall, error)
+pkg nosql, type DatabaseClientStub interface, ResumeSync(*context.T, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, SetSchemaMetadata(*context.T, SchemaMetadata, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, SetSyncgroupSpec(*context.T, string, SyncgroupSpec, string, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, StartConflictResolver(*context.T, ...rpc.CallOpt) (ConflictManagerStartConflictResolverClientCall, error)
+pkg nosql, type DatabaseClientStub interface, UnpinBlob(*context.T, BlobRef, ...rpc.CallOpt) error
+pkg nosql, type DatabaseClientStub interface, unexported methods
+pkg nosql, type DatabaseExecClientCall interface { Finish, RecvStream }
+pkg nosql, type DatabaseExecClientCall interface, Finish() error
+pkg nosql, type DatabaseExecClientCall interface, RecvStream() interface { Advance() bool;; Value() []*vom.RawBytes;; Err() error;}
+pkg nosql, type DatabaseExecClientStream interface { RecvStream }
+pkg nosql, type DatabaseExecClientStream interface, RecvStream() interface { Advance() bool;; Value() []*vom.RawBytes;; Err() error;}
+pkg nosql, type DatabaseExecServerCall interface, SendStream() interface { Send(item []*vom.RawBytes) error;}
+pkg nosql, type DatabaseExecServerCall interface, unexported methods
+pkg nosql, type DatabaseExecServerCallStub struct
+pkg nosql, type DatabaseExecServerCallStub struct, embedded rpc.StreamServerCall
+pkg nosql, type DatabaseExecServerStream interface { SendStream }
+pkg nosql, type DatabaseExecServerStream interface, SendStream() interface { Send(item []*vom.RawBytes) error;}
+pkg nosql, type DatabaseServerMethods interface, Abort(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type DatabaseServerMethods interface, BeginBatch(*context.T, rpc.ServerCall, int32, BatchOptions) (string, error)
+pkg nosql, type DatabaseServerMethods interface, Commit(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type DatabaseServerMethods interface, CommitBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type DatabaseServerMethods interface, Create(*context.T, rpc.ServerCall, *SchemaMetadata, access.Permissions) error
+pkg nosql, type DatabaseServerMethods interface, CreateBlob(*context.T, rpc.ServerCall) (BlobRef, error)
+pkg nosql, type DatabaseServerMethods interface, CreateSyncgroup(*context.T, rpc.ServerCall, string, SyncgroupSpec, SyncgroupMemberInfo) error
+pkg nosql, type DatabaseServerMethods interface, DeleteBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type DatabaseServerMethods interface, Destroy(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type DatabaseServerMethods interface, DestroySyncgroup(*context.T, rpc.ServerCall, string) error
+pkg nosql, type DatabaseServerMethods interface, EjectFromSyncgroup(*context.T, rpc.ServerCall, string, string) error
+pkg nosql, type DatabaseServerMethods interface, Exec(*context.T, DatabaseExecServerCall, int32, string, []*vom.RawBytes) error
+pkg nosql, type DatabaseServerMethods interface, Exists(*context.T, rpc.ServerCall, int32) (bool, error)
+pkg nosql, type DatabaseServerMethods interface, FetchBlob(*context.T, BlobManagerFetchBlobServerCall, BlobRef, uint64) error
+pkg nosql, type DatabaseServerMethods interface, GetBlob(*context.T, BlobManagerGetBlobServerCall, BlobRef, int64) error
+pkg nosql, type DatabaseServerMethods interface, GetBlobSize(*context.T, rpc.ServerCall, BlobRef) (int64, error)
+pkg nosql, type DatabaseServerMethods interface, GetResumeMarker(*context.T, rpc.ServerCall) (watch.ResumeMarker, error)
+pkg nosql, type DatabaseServerMethods interface, GetSchemaMetadata(*context.T, rpc.ServerCall) (SchemaMetadata, error)
+pkg nosql, type DatabaseServerMethods interface, GetSyncgroupMembers(*context.T, rpc.ServerCall, string) (map[string]SyncgroupMemberInfo, error)
+pkg nosql, type DatabaseServerMethods interface, GetSyncgroupNames(*context.T, rpc.ServerCall) ([]string, error)
+pkg nosql, type DatabaseServerMethods interface, GetSyncgroupSpec(*context.T, rpc.ServerCall, string) (SyncgroupSpec, string, error)
+pkg nosql, type DatabaseServerMethods interface, JoinSyncgroup(*context.T, rpc.ServerCall, string, SyncgroupMemberInfo) (SyncgroupSpec, error)
+pkg nosql, type DatabaseServerMethods interface, KeepBlob(*context.T, rpc.ServerCall, BlobRef, uint64) error
+pkg nosql, type DatabaseServerMethods interface, LeaveSyncgroup(*context.T, rpc.ServerCall, string) error
+pkg nosql, type DatabaseServerMethods interface, ListTables(*context.T, rpc.ServerCall) ([]string, error)
+pkg nosql, type DatabaseServerMethods interface, PauseSync(*context.T, rpc.ServerCall) error
+pkg nosql, type DatabaseServerMethods interface, PinBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type DatabaseServerMethods interface, PutBlob(*context.T, BlobManagerPutBlobServerCall, BlobRef) error
+pkg nosql, type DatabaseServerMethods interface, ResumeSync(*context.T, rpc.ServerCall) error
+pkg nosql, type DatabaseServerMethods interface, SetSchemaMetadata(*context.T, rpc.ServerCall, SchemaMetadata) error
+pkg nosql, type DatabaseServerMethods interface, SetSyncgroupSpec(*context.T, rpc.ServerCall, string, SyncgroupSpec, string) error
+pkg nosql, type DatabaseServerMethods interface, StartConflictResolver(*context.T, ConflictManagerStartConflictResolverServerCall) error
+pkg nosql, type DatabaseServerMethods interface, UnpinBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type DatabaseServerMethods interface, unexported methods
+pkg nosql, type DatabaseServerStub interface, Abort(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type DatabaseServerStub interface, BeginBatch(*context.T, rpc.ServerCall, int32, BatchOptions) (string, error)
+pkg nosql, type DatabaseServerStub interface, Commit(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type DatabaseServerStub interface, CommitBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type DatabaseServerStub interface, Create(*context.T, rpc.ServerCall, *SchemaMetadata, access.Permissions) error
+pkg nosql, type DatabaseServerStub interface, CreateBlob(*context.T, rpc.ServerCall) (BlobRef, error)
+pkg nosql, type DatabaseServerStub interface, DeleteBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type DatabaseServerStub interface, Describe__() []rpc.InterfaceDesc
+pkg nosql, type DatabaseServerStub interface, Destroy(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type DatabaseServerStub interface, Exec(*context.T, *DatabaseExecServerCallStub, int32, string, []*vom.RawBytes) error
+pkg nosql, type DatabaseServerStub interface, Exists(*context.T, rpc.ServerCall, int32) (bool, error)
+pkg nosql, type DatabaseServerStub interface, FetchBlob(*context.T, *BlobManagerFetchBlobServerCallStub, BlobRef, uint64) error
+pkg nosql, type DatabaseServerStub interface, GetBlob(*context.T, *BlobManagerGetBlobServerCallStub, BlobRef, int64) error
+pkg nosql, type DatabaseServerStub interface, GetBlobSize(*context.T, rpc.ServerCall, BlobRef) (int64, error)
+pkg nosql, type DatabaseServerStub interface, GetResumeMarker(*context.T, rpc.ServerCall) (watch.ResumeMarker, error)
+pkg nosql, type DatabaseServerStub interface, KeepBlob(*context.T, rpc.ServerCall, BlobRef, uint64) error
+pkg nosql, type DatabaseServerStub interface, ListTables(*context.T, rpc.ServerCall) ([]string, error)
+pkg nosql, type DatabaseServerStub interface, PauseSync(*context.T, rpc.ServerCall) error
+pkg nosql, type DatabaseServerStub interface, PinBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type DatabaseServerStub interface, PutBlob(*context.T, *BlobManagerPutBlobServerCallStub, BlobRef) error
+pkg nosql, type DatabaseServerStub interface, ResumeSync(*context.T, rpc.ServerCall) error
+pkg nosql, type DatabaseServerStub interface, StartConflictResolver(*context.T, *ConflictManagerStartConflictResolverServerCallStub) error
+pkg nosql, type DatabaseServerStub interface, UnpinBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type DatabaseServerStub interface, unexported methods
+pkg nosql, type DatabaseServerStubMethods interface, Abort(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type DatabaseServerStubMethods interface, BeginBatch(*context.T, rpc.ServerCall, int32, BatchOptions) (string, error)
+pkg nosql, type DatabaseServerStubMethods interface, Commit(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type DatabaseServerStubMethods interface, CommitBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type DatabaseServerStubMethods interface, Create(*context.T, rpc.ServerCall, *SchemaMetadata, access.Permissions) error
+pkg nosql, type DatabaseServerStubMethods interface, CreateBlob(*context.T, rpc.ServerCall) (BlobRef, error)
+pkg nosql, type DatabaseServerStubMethods interface, DeleteBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type DatabaseServerStubMethods interface, Destroy(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type DatabaseServerStubMethods interface, Exec(*context.T, *DatabaseExecServerCallStub, int32, string, []*vom.RawBytes) error
+pkg nosql, type DatabaseServerStubMethods interface, Exists(*context.T, rpc.ServerCall, int32) (bool, error)
+pkg nosql, type DatabaseServerStubMethods interface, FetchBlob(*context.T, *BlobManagerFetchBlobServerCallStub, BlobRef, uint64) error
+pkg nosql, type DatabaseServerStubMethods interface, GetBlob(*context.T, *BlobManagerGetBlobServerCallStub, BlobRef, int64) error
+pkg nosql, type DatabaseServerStubMethods interface, GetBlobSize(*context.T, rpc.ServerCall, BlobRef) (int64, error)
+pkg nosql, type DatabaseServerStubMethods interface, GetResumeMarker(*context.T, rpc.ServerCall) (watch.ResumeMarker, error)
+pkg nosql, type DatabaseServerStubMethods interface, KeepBlob(*context.T, rpc.ServerCall, BlobRef, uint64) error
+pkg nosql, type DatabaseServerStubMethods interface, ListTables(*context.T, rpc.ServerCall) ([]string, error)
+pkg nosql, type DatabaseServerStubMethods interface, PauseSync(*context.T, rpc.ServerCall) error
+pkg nosql, type DatabaseServerStubMethods interface, PinBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type DatabaseServerStubMethods interface, PutBlob(*context.T, *BlobManagerPutBlobServerCallStub, BlobRef) error
+pkg nosql, type DatabaseServerStubMethods interface, ResumeSync(*context.T, rpc.ServerCall) error
+pkg nosql, type DatabaseServerStubMethods interface, StartConflictResolver(*context.T, *ConflictManagerStartConflictResolverServerCallStub) error
+pkg nosql, type DatabaseServerStubMethods interface, UnpinBlob(*context.T, rpc.ServerCall, BlobRef) error
+pkg nosql, type DatabaseServerStubMethods interface, unexported methods
+pkg nosql, type DatabaseWatcherClientMethods interface, GetResumeMarker(*context.T, ...rpc.CallOpt) (watch.ResumeMarker, error)
+pkg nosql, type DatabaseWatcherClientMethods interface, unexported methods
+pkg nosql, type DatabaseWatcherClientStub interface, GetResumeMarker(*context.T, ...rpc.CallOpt) (watch.ResumeMarker, error)
+pkg nosql, type DatabaseWatcherClientStub interface, unexported methods
+pkg nosql, type DatabaseWatcherServerMethods interface, GetResumeMarker(*context.T, rpc.ServerCall) (watch.ResumeMarker, error)
+pkg nosql, type DatabaseWatcherServerMethods interface, unexported methods
+pkg nosql, type DatabaseWatcherServerStub interface, Describe__() []rpc.InterfaceDesc
+pkg nosql, type DatabaseWatcherServerStub interface, GetResumeMarker(*context.T, rpc.ServerCall) (watch.ResumeMarker, error)
+pkg nosql, type DatabaseWatcherServerStub interface, unexported methods
+pkg nosql, type DatabaseWatcherServerStubMethods interface, GetResumeMarker(*context.T, rpc.ServerCall) (watch.ResumeMarker, error)
+pkg nosql, type DatabaseWatcherServerStubMethods interface, unexported methods
+pkg nosql, type KeyValue struct
+pkg nosql, type KeyValue struct, Key string
+pkg nosql, type KeyValue struct, Value []byte
+pkg nosql, type KeyValueTarget struct
+pkg nosql, type KeyValueTarget struct, Value *KeyValue
+pkg nosql, type KeyValueTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type KeyValueTarget struct, embedded vdl.TargetBase
+pkg nosql, type Operation interface, FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, type Operation interface, Index() int
+pkg nosql, type Operation interface, Interface() interface{}
+pkg nosql, type Operation interface, Name() string
+pkg nosql, type Operation interface, unexported methods
+pkg nosql, type OperationRead struct
+pkg nosql, type OperationRead struct, Value RowOp
+pkg nosql, type OperationScan struct
+pkg nosql, type OperationScan struct, Value ScanOp
+pkg nosql, type OperationTarget struct
+pkg nosql, type OperationTarget struct, Value *Operation
+pkg nosql, type OperationTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type OperationTarget struct, embedded vdl.TargetBase
+pkg nosql, type OperationWrite struct
+pkg nosql, type OperationWrite struct, Value RowOp
+pkg nosql, type PrefixPermissions struct
+pkg nosql, type PrefixPermissions struct, Perms access.Permissions
+pkg nosql, type PrefixPermissions struct, Prefix string
+pkg nosql, type PrefixPermissionsTarget struct
+pkg nosql, type PrefixPermissionsTarget struct, Value *PrefixPermissions
+pkg nosql, type PrefixPermissionsTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type PrefixPermissionsTarget struct, embedded vdl.TargetBase
+pkg nosql, type ResolutionInfo struct
+pkg nosql, type ResolutionInfo struct, Continued bool
+pkg nosql, type ResolutionInfo struct, Key string
+pkg nosql, type ResolutionInfo struct, Result *Value
+pkg nosql, type ResolutionInfo struct, Selection ValueSelection
+pkg nosql, type ResolutionInfoTarget struct
+pkg nosql, type ResolutionInfoTarget struct, Value *ResolutionInfo
+pkg nosql, type ResolutionInfoTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type ResolutionInfoTarget struct, embedded vdl.TargetBase
+pkg nosql, type ResolverType int
+pkg nosql, type ResolverTypeTarget struct
+pkg nosql, type ResolverTypeTarget struct, Value *ResolverType
+pkg nosql, type ResolverTypeTarget struct, embedded vdl.TargetBase
+pkg nosql, type RowClientMethods interface { Delete, Exists, Get, Put }
+pkg nosql, type RowClientMethods interface, Delete(*context.T, int32, ...rpc.CallOpt) error
+pkg nosql, type RowClientMethods interface, Exists(*context.T, int32, ...rpc.CallOpt) (bool, error)
+pkg nosql, type RowClientMethods interface, Get(*context.T, int32, ...rpc.CallOpt) ([]byte, error)
+pkg nosql, type RowClientMethods interface, Put(*context.T, int32, []byte, ...rpc.CallOpt) error
+pkg nosql, type RowClientStub interface, Delete(*context.T, int32, ...rpc.CallOpt) error
+pkg nosql, type RowClientStub interface, Exists(*context.T, int32, ...rpc.CallOpt) (bool, error)
+pkg nosql, type RowClientStub interface, Get(*context.T, int32, ...rpc.CallOpt) ([]byte, error)
+pkg nosql, type RowClientStub interface, Put(*context.T, int32, []byte, ...rpc.CallOpt) error
+pkg nosql, type RowClientStub interface, unexported methods
+pkg nosql, type RowInfo struct
+pkg nosql, type RowInfo struct, BatchIds []uint64
+pkg nosql, type RowInfo struct, Op Operation
+pkg nosql, type RowInfoTarget struct
+pkg nosql, type RowInfoTarget struct, Value *RowInfo
+pkg nosql, type RowInfoTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type RowInfoTarget struct, embedded vdl.TargetBase
+pkg nosql, type RowOp struct
+pkg nosql, type RowOp struct, AncestorValue *Value
+pkg nosql, type RowOp struct, Key string
+pkg nosql, type RowOp struct, LocalValue *Value
+pkg nosql, type RowOp struct, RemoteValue *Value
+pkg nosql, type RowOpTarget struct
+pkg nosql, type RowOpTarget struct, Value *RowOp
+pkg nosql, type RowOpTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type RowOpTarget struct, embedded vdl.TargetBase
+pkg nosql, type RowServerMethods interface { Delete, Exists, Get, Put }
+pkg nosql, type RowServerMethods interface, Delete(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type RowServerMethods interface, Exists(*context.T, rpc.ServerCall, int32) (bool, error)
+pkg nosql, type RowServerMethods interface, Get(*context.T, rpc.ServerCall, int32) ([]byte, error)
+pkg nosql, type RowServerMethods interface, Put(*context.T, rpc.ServerCall, int32, []byte) error
+pkg nosql, type RowServerStub interface, Describe__() []rpc.InterfaceDesc
+pkg nosql, type RowServerStub interface, unexported methods
+pkg nosql, type RowServerStubMethods RowServerMethods
+pkg nosql, type ScanOp struct
+pkg nosql, type ScanOp struct, Limit string
+pkg nosql, type ScanOp struct, Start string
+pkg nosql, type ScanOpTarget struct
+pkg nosql, type ScanOpTarget struct, Value *ScanOp
+pkg nosql, type ScanOpTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type ScanOpTarget struct, embedded vdl.TargetBase
+pkg nosql, type SchemaManagerClientMethods interface { GetSchemaMetadata, SetSchemaMetadata }
+pkg nosql, type SchemaManagerClientMethods interface, GetSchemaMetadata(*context.T, ...rpc.CallOpt) (SchemaMetadata, error)
+pkg nosql, type SchemaManagerClientMethods interface, SetSchemaMetadata(*context.T, SchemaMetadata, ...rpc.CallOpt) error
+pkg nosql, type SchemaManagerClientStub interface, GetSchemaMetadata(*context.T, ...rpc.CallOpt) (SchemaMetadata, error)
+pkg nosql, type SchemaManagerClientStub interface, SetSchemaMetadata(*context.T, SchemaMetadata, ...rpc.CallOpt) error
+pkg nosql, type SchemaManagerClientStub interface, unexported methods
+pkg nosql, type SchemaManagerServerMethods interface { GetSchemaMetadata, SetSchemaMetadata }
+pkg nosql, type SchemaManagerServerMethods interface, GetSchemaMetadata(*context.T, rpc.ServerCall) (SchemaMetadata, error)
+pkg nosql, type SchemaManagerServerMethods interface, SetSchemaMetadata(*context.T, rpc.ServerCall, SchemaMetadata) error
+pkg nosql, type SchemaManagerServerStub interface, Describe__() []rpc.InterfaceDesc
+pkg nosql, type SchemaManagerServerStub interface, unexported methods
+pkg nosql, type SchemaManagerServerStubMethods SchemaManagerServerMethods
+pkg nosql, type SchemaMetadata struct
+pkg nosql, type SchemaMetadata struct, Policy CrPolicy
+pkg nosql, type SchemaMetadata struct, Version int32
+pkg nosql, type SchemaMetadataTarget struct
+pkg nosql, type SchemaMetadataTarget struct, Value *SchemaMetadata
+pkg nosql, type SchemaMetadataTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type SchemaMetadataTarget struct, embedded vdl.TargetBase
+pkg nosql, type StoreChange struct
+pkg nosql, type StoreChange struct, FromSync bool
+pkg nosql, type StoreChange struct, Value []byte
+pkg nosql, type StoreChangeTarget struct
+pkg nosql, type StoreChangeTarget struct, Value *StoreChange
+pkg nosql, type StoreChangeTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type StoreChangeTarget struct, embedded vdl.TargetBase
+pkg nosql, type SyncgroupManagerClientMethods interface { CreateSyncgroup, DestroySyncgroup, EjectFromSyncgroup, GetSyncgroupMembers, GetSyncgroupNames, GetSyncgroupSpec, JoinSyncgroup, LeaveSyncgroup, SetSyncgroupSpec }
+pkg nosql, type SyncgroupManagerClientMethods interface, CreateSyncgroup(*context.T, string, SyncgroupSpec, SyncgroupMemberInfo, ...rpc.CallOpt) error
+pkg nosql, type SyncgroupManagerClientMethods interface, DestroySyncgroup(*context.T, string, ...rpc.CallOpt) error
+pkg nosql, type SyncgroupManagerClientMethods interface, EjectFromSyncgroup(*context.T, string, string, ...rpc.CallOpt) error
+pkg nosql, type SyncgroupManagerClientMethods interface, GetSyncgroupMembers(*context.T, string, ...rpc.CallOpt) (map[string]SyncgroupMemberInfo, error)
+pkg nosql, type SyncgroupManagerClientMethods interface, GetSyncgroupNames(*context.T, ...rpc.CallOpt) ([]string, error)
+pkg nosql, type SyncgroupManagerClientMethods interface, GetSyncgroupSpec(*context.T, string, ...rpc.CallOpt) (SyncgroupSpec, string, error)
+pkg nosql, type SyncgroupManagerClientMethods interface, JoinSyncgroup(*context.T, string, SyncgroupMemberInfo, ...rpc.CallOpt) (SyncgroupSpec, error)
+pkg nosql, type SyncgroupManagerClientMethods interface, LeaveSyncgroup(*context.T, string, ...rpc.CallOpt) error
+pkg nosql, type SyncgroupManagerClientMethods interface, SetSyncgroupSpec(*context.T, string, SyncgroupSpec, string, ...rpc.CallOpt) error
+pkg nosql, type SyncgroupManagerClientStub interface, CreateSyncgroup(*context.T, string, SyncgroupSpec, SyncgroupMemberInfo, ...rpc.CallOpt) error
+pkg nosql, type SyncgroupManagerClientStub interface, DestroySyncgroup(*context.T, string, ...rpc.CallOpt) error
+pkg nosql, type SyncgroupManagerClientStub interface, EjectFromSyncgroup(*context.T, string, string, ...rpc.CallOpt) error
+pkg nosql, type SyncgroupManagerClientStub interface, GetSyncgroupMembers(*context.T, string, ...rpc.CallOpt) (map[string]SyncgroupMemberInfo, error)
+pkg nosql, type SyncgroupManagerClientStub interface, GetSyncgroupNames(*context.T, ...rpc.CallOpt) ([]string, error)
+pkg nosql, type SyncgroupManagerClientStub interface, GetSyncgroupSpec(*context.T, string, ...rpc.CallOpt) (SyncgroupSpec, string, error)
+pkg nosql, type SyncgroupManagerClientStub interface, JoinSyncgroup(*context.T, string, SyncgroupMemberInfo, ...rpc.CallOpt) (SyncgroupSpec, error)
+pkg nosql, type SyncgroupManagerClientStub interface, LeaveSyncgroup(*context.T, string, ...rpc.CallOpt) error
+pkg nosql, type SyncgroupManagerClientStub interface, SetSyncgroupSpec(*context.T, string, SyncgroupSpec, string, ...rpc.CallOpt) error
+pkg nosql, type SyncgroupManagerClientStub interface, unexported methods
+pkg nosql, type SyncgroupManagerServerMethods interface { CreateSyncgroup, DestroySyncgroup, EjectFromSyncgroup, GetSyncgroupMembers, GetSyncgroupNames, GetSyncgroupSpec, JoinSyncgroup, LeaveSyncgroup, SetSyncgroupSpec }
+pkg nosql, type SyncgroupManagerServerMethods interface, CreateSyncgroup(*context.T, rpc.ServerCall, string, SyncgroupSpec, SyncgroupMemberInfo) error
+pkg nosql, type SyncgroupManagerServerMethods interface, DestroySyncgroup(*context.T, rpc.ServerCall, string) error
+pkg nosql, type SyncgroupManagerServerMethods interface, EjectFromSyncgroup(*context.T, rpc.ServerCall, string, string) error
+pkg nosql, type SyncgroupManagerServerMethods interface, GetSyncgroupMembers(*context.T, rpc.ServerCall, string) (map[string]SyncgroupMemberInfo, error)
+pkg nosql, type SyncgroupManagerServerMethods interface, GetSyncgroupNames(*context.T, rpc.ServerCall) ([]string, error)
+pkg nosql, type SyncgroupManagerServerMethods interface, GetSyncgroupSpec(*context.T, rpc.ServerCall, string) (SyncgroupSpec, string, error)
+pkg nosql, type SyncgroupManagerServerMethods interface, JoinSyncgroup(*context.T, rpc.ServerCall, string, SyncgroupMemberInfo) (SyncgroupSpec, error)
+pkg nosql, type SyncgroupManagerServerMethods interface, LeaveSyncgroup(*context.T, rpc.ServerCall, string) error
+pkg nosql, type SyncgroupManagerServerMethods interface, SetSyncgroupSpec(*context.T, rpc.ServerCall, string, SyncgroupSpec, string) error
+pkg nosql, type SyncgroupManagerServerStub interface, Describe__() []rpc.InterfaceDesc
+pkg nosql, type SyncgroupManagerServerStub interface, unexported methods
+pkg nosql, type SyncgroupManagerServerStubMethods SyncgroupManagerServerMethods
+pkg nosql, type SyncgroupMemberInfo struct
+pkg nosql, type SyncgroupMemberInfo struct, IsServer bool
+pkg nosql, type SyncgroupMemberInfo struct, SyncPriority byte
+pkg nosql, type SyncgroupMemberInfoTarget struct
+pkg nosql, type SyncgroupMemberInfoTarget struct, Value *SyncgroupMemberInfo
+pkg nosql, type SyncgroupMemberInfoTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type SyncgroupMemberInfoTarget struct, embedded vdl.TargetBase
+pkg nosql, type SyncgroupSpec struct
+pkg nosql, type SyncgroupSpec struct, Description string
+pkg nosql, type SyncgroupSpec struct, IsPrivate bool
+pkg nosql, type SyncgroupSpec struct, MountTables []string
+pkg nosql, type SyncgroupSpec struct, Perms access.Permissions
+pkg nosql, type SyncgroupSpec struct, Prefixes []TableRow
+pkg nosql, type SyncgroupSpecTarget struct
+pkg nosql, type SyncgroupSpecTarget struct, Value *SyncgroupSpec
+pkg nosql, type SyncgroupSpecTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type SyncgroupSpecTarget struct, embedded vdl.TargetBase
+pkg nosql, type TableClientMethods interface { Create, DeletePrefixPermissions, DeleteRange, Destroy, Exists, GetPermissions, GetPrefixPermissions, Scan, SetPermissions, SetPrefixPermissions }
+pkg nosql, type TableClientMethods interface, Create(*context.T, int32, access.Permissions, ...rpc.CallOpt) error
+pkg nosql, type TableClientMethods interface, DeletePrefixPermissions(*context.T, int32, string, ...rpc.CallOpt) error
+pkg nosql, type TableClientMethods interface, DeleteRange(*context.T, int32, []byte, []byte, ...rpc.CallOpt) error
+pkg nosql, type TableClientMethods interface, Destroy(*context.T, int32, ...rpc.CallOpt) error
+pkg nosql, type TableClientMethods interface, Exists(*context.T, int32, ...rpc.CallOpt) (bool, error)
+pkg nosql, type TableClientMethods interface, GetPermissions(*context.T, int32, ...rpc.CallOpt) (access.Permissions, error)
+pkg nosql, type TableClientMethods interface, GetPrefixPermissions(*context.T, int32, string, ...rpc.CallOpt) ([]PrefixPermissions, error)
+pkg nosql, type TableClientMethods interface, Scan(*context.T, int32, []byte, []byte, ...rpc.CallOpt) (TableScanClientCall, error)
+pkg nosql, type TableClientMethods interface, SetPermissions(*context.T, int32, access.Permissions, ...rpc.CallOpt) error
+pkg nosql, type TableClientMethods interface, SetPrefixPermissions(*context.T, int32, string, access.Permissions, ...rpc.CallOpt) error
+pkg nosql, type TableClientStub interface, Create(*context.T, int32, access.Permissions, ...rpc.CallOpt) error
+pkg nosql, type TableClientStub interface, DeletePrefixPermissions(*context.T, int32, string, ...rpc.CallOpt) error
+pkg nosql, type TableClientStub interface, DeleteRange(*context.T, int32, []byte, []byte, ...rpc.CallOpt) error
+pkg nosql, type TableClientStub interface, Destroy(*context.T, int32, ...rpc.CallOpt) error
+pkg nosql, type TableClientStub interface, Exists(*context.T, int32, ...rpc.CallOpt) (bool, error)
+pkg nosql, type TableClientStub interface, GetPermissions(*context.T, int32, ...rpc.CallOpt) (access.Permissions, error)
+pkg nosql, type TableClientStub interface, GetPrefixPermissions(*context.T, int32, string, ...rpc.CallOpt) ([]PrefixPermissions, error)
+pkg nosql, type TableClientStub interface, Scan(*context.T, int32, []byte, []byte, ...rpc.CallOpt) (TableScanClientCall, error)
+pkg nosql, type TableClientStub interface, SetPermissions(*context.T, int32, access.Permissions, ...rpc.CallOpt) error
+pkg nosql, type TableClientStub interface, SetPrefixPermissions(*context.T, int32, string, access.Permissions, ...rpc.CallOpt) error
+pkg nosql, type TableClientStub interface, unexported methods
+pkg nosql, type TableRow struct
+pkg nosql, type TableRow struct, Row string
+pkg nosql, type TableRow struct, TableName string
+pkg nosql, type TableRowTarget struct
+pkg nosql, type TableRowTarget struct, Value *TableRow
+pkg nosql, type TableRowTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type TableRowTarget struct, embedded vdl.TargetBase
+pkg nosql, type TableScanClientCall interface { Finish, RecvStream }
+pkg nosql, type TableScanClientCall interface, Finish() error
+pkg nosql, type TableScanClientCall interface, RecvStream() interface { Advance() bool;; Value() KeyValue;; Err() error;}
+pkg nosql, type TableScanClientStream interface { RecvStream }
+pkg nosql, type TableScanClientStream interface, RecvStream() interface { Advance() bool;; Value() KeyValue;; Err() error;}
+pkg nosql, type TableScanServerCall interface, SendStream() interface { Send(item KeyValue) error;}
+pkg nosql, type TableScanServerCall interface, unexported methods
+pkg nosql, type TableScanServerCallStub struct
+pkg nosql, type TableScanServerCallStub struct, embedded rpc.StreamServerCall
+pkg nosql, type TableScanServerStream interface { SendStream }
+pkg nosql, type TableScanServerStream interface, SendStream() interface { Send(item KeyValue) error;}
+pkg nosql, type TableServerMethods interface { Create, DeletePrefixPermissions, DeleteRange, Destroy, Exists, GetPermissions, GetPrefixPermissions, Scan, SetPermissions, SetPrefixPermissions }
+pkg nosql, type TableServerMethods interface, Create(*context.T, rpc.ServerCall, int32, access.Permissions) error
+pkg nosql, type TableServerMethods interface, DeletePrefixPermissions(*context.T, rpc.ServerCall, int32, string) error
+pkg nosql, type TableServerMethods interface, DeleteRange(*context.T, rpc.ServerCall, int32, []byte, []byte) error
+pkg nosql, type TableServerMethods interface, Destroy(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type TableServerMethods interface, Exists(*context.T, rpc.ServerCall, int32) (bool, error)
+pkg nosql, type TableServerMethods interface, GetPermissions(*context.T, rpc.ServerCall, int32) (access.Permissions, error)
+pkg nosql, type TableServerMethods interface, GetPrefixPermissions(*context.T, rpc.ServerCall, int32, string) ([]PrefixPermissions, error)
+pkg nosql, type TableServerMethods interface, Scan(*context.T, TableScanServerCall, int32, []byte, []byte) error
+pkg nosql, type TableServerMethods interface, SetPermissions(*context.T, rpc.ServerCall, int32, access.Permissions) error
+pkg nosql, type TableServerMethods interface, SetPrefixPermissions(*context.T, rpc.ServerCall, int32, string, access.Permissions) error
+pkg nosql, type TableServerStub interface { Create, DeletePrefixPermissions, DeleteRange, Describe__, Destroy, Exists, GetPermissions, GetPrefixPermissions, Scan, SetPermissions, SetPrefixPermissions }
+pkg nosql, type TableServerStub interface, Create(*context.T, rpc.ServerCall, int32, access.Permissions) error
+pkg nosql, type TableServerStub interface, DeletePrefixPermissions(*context.T, rpc.ServerCall, int32, string) error
+pkg nosql, type TableServerStub interface, DeleteRange(*context.T, rpc.ServerCall, int32, []byte, []byte) error
+pkg nosql, type TableServerStub interface, Describe__() []rpc.InterfaceDesc
+pkg nosql, type TableServerStub interface, Destroy(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type TableServerStub interface, Exists(*context.T, rpc.ServerCall, int32) (bool, error)
+pkg nosql, type TableServerStub interface, GetPermissions(*context.T, rpc.ServerCall, int32) (access.Permissions, error)
+pkg nosql, type TableServerStub interface, GetPrefixPermissions(*context.T, rpc.ServerCall, int32, string) ([]PrefixPermissions, error)
+pkg nosql, type TableServerStub interface, Scan(*context.T, *TableScanServerCallStub, int32, []byte, []byte) error
+pkg nosql, type TableServerStub interface, SetPermissions(*context.T, rpc.ServerCall, int32, access.Permissions) error
+pkg nosql, type TableServerStub interface, SetPrefixPermissions(*context.T, rpc.ServerCall, int32, string, access.Permissions) error
+pkg nosql, type TableServerStubMethods interface { Create, DeletePrefixPermissions, DeleteRange, Destroy, Exists, GetPermissions, GetPrefixPermissions, Scan, SetPermissions, SetPrefixPermissions }
+pkg nosql, type TableServerStubMethods interface, Create(*context.T, rpc.ServerCall, int32, access.Permissions) error
+pkg nosql, type TableServerStubMethods interface, DeletePrefixPermissions(*context.T, rpc.ServerCall, int32, string) error
+pkg nosql, type TableServerStubMethods interface, DeleteRange(*context.T, rpc.ServerCall, int32, []byte, []byte) error
+pkg nosql, type TableServerStubMethods interface, Destroy(*context.T, rpc.ServerCall, int32) error
+pkg nosql, type TableServerStubMethods interface, Exists(*context.T, rpc.ServerCall, int32) (bool, error)
+pkg nosql, type TableServerStubMethods interface, GetPermissions(*context.T, rpc.ServerCall, int32) (access.Permissions, error)
+pkg nosql, type TableServerStubMethods interface, GetPrefixPermissions(*context.T, rpc.ServerCall, int32, string) ([]PrefixPermissions, error)
+pkg nosql, type TableServerStubMethods interface, Scan(*context.T, *TableScanServerCallStub, int32, []byte, []byte) error
+pkg nosql, type TableServerStubMethods interface, SetPermissions(*context.T, rpc.ServerCall, int32, access.Permissions) error
+pkg nosql, type TableServerStubMethods interface, SetPrefixPermissions(*context.T, rpc.ServerCall, int32, string, access.Permissions) error
+pkg nosql, type Value struct
+pkg nosql, type Value struct, Bytes []byte
+pkg nosql, type Value struct, State ValueState
+pkg nosql, type Value struct, WriteTs time.Time
+pkg nosql, type ValueSelection int
+pkg nosql, type ValueSelectionTarget struct
+pkg nosql, type ValueSelectionTarget struct, Value *ValueSelection
+pkg nosql, type ValueSelectionTarget struct, embedded vdl.TargetBase
+pkg nosql, type ValueState int
+pkg nosql, type ValueStateTarget struct
+pkg nosql, type ValueStateTarget struct, Value *ValueState
+pkg nosql, type ValueStateTarget struct, embedded vdl.TargetBase
+pkg nosql, type ValueTarget struct
+pkg nosql, type ValueTarget struct, Value *Value
+pkg nosql, type ValueTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type ValueTarget struct, embedded vdl.TargetBase
+pkg nosql, var BatchSourceAll [...]BatchSource
+pkg nosql, var BlobFetchStateAll [...]BlobFetchState
+pkg nosql, var BlobManagerDesc rpc.InterfaceDesc
+pkg nosql, var ConflictManagerDesc rpc.InterfaceDesc
+pkg nosql, var DatabaseDesc rpc.InterfaceDesc
+pkg nosql, var DatabaseWatcherDesc rpc.InterfaceDesc
+pkg nosql, var ErrBlobNotCommitted unknown-type
+pkg nosql, var ErrBoundToBatch unknown-type
+pkg nosql, var ErrConcurrentBatch unknown-type
+pkg nosql, var ErrNotBoundToBatch unknown-type
+pkg nosql, var ErrReadOnlyBatch unknown-type
+pkg nosql, var ErrSchemaVersionMismatch unknown-type
+pkg nosql, var ErrSyncgroupJoinFailed unknown-type
+pkg nosql, var ResolverTypeAll [...]ResolverType
+pkg nosql, var RowDesc rpc.InterfaceDesc
+pkg nosql, var SchemaManagerDesc rpc.InterfaceDesc
+pkg nosql, var SyncgroupManagerDesc rpc.InterfaceDesc
+pkg nosql, var TableDesc rpc.InterfaceDesc
+pkg nosql, var ValueSelectionAll [...]ValueSelection
+pkg nosql, var ValueStateAll [...]ValueState
diff --git a/services/syncbase/nosql/nosql.vdl.go b/services/syncbase/nosql/nosql.vdl.go
new file mode 100644
index 0000000..e751355
--- /dev/null
+++ b/services/syncbase/nosql/nosql.vdl.go
@@ -0,0 +1,6918 @@
+// Copyright 2015 The Vanadium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file was auto-generated by the vanadium vdl tool.
+// Package: nosql
+
+// Package nosql defines the wire API for the NoSQL part of Syncbase.
+package nosql
+
+import (
+ "fmt"
+ "io"
+ "time"
+ "v.io/v23"
+ "v.io/v23/context"
+ "v.io/v23/i18n"
+ "v.io/v23/rpc"
+ "v.io/v23/security/access"
+ "v.io/v23/services/permissions"
+ "v.io/v23/services/watch"
+ "v.io/v23/vdl"
+ time_2 "v.io/v23/vdlroot/time"
+ "v.io/v23/verror"
+ "v.io/v23/vom"
+)
+
+var _ = __VDLInit() // Must be first; see __VDLInit comments for details.
+
+//////////////////////////////////////////////////
+// Type definitions
+
+// BatchOptions configures a batch.
+// TODO(sadovsky): Add more options, e.g. to configure isolation, timeouts,
+// whether to track the read set and/or write set, etc.
+// TODO(sadovsky): Maybe add a DefaultBatchOptions() function that initializes
+// BatchOptions with our desired defaults. Clients would be encouraged to
+// initialize their BatchOptions object using that function and then modify it
+// to their liking.
+type BatchOptions struct {
+ // Arbitrary string, typically used to describe the intent behind a batch.
+ // Hints are surfaced to clients during conflict resolution.
+ // TODO(sadovsky): Use "any" here?
+ Hint string
+ // ReadOnly specifies whether the batch should allow writes.
+ // If ReadOnly is set to true, Abort() should be used to release any resources
+ // associated with this batch (though it is not strictly required), and
+ // Commit() will always fail.
+ ReadOnly bool
+}
+
+func (BatchOptions) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.BatchOptions"`
+}) {
+}
+
+func (m *BatchOptions) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Hint")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.Hint == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Hint), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("ReadOnly")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var7 := (m.ReadOnly == false)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromBool(bool(m.ReadOnly), 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 *BatchOptions) MakeVDLTarget() vdl.Target {
+ return &BatchOptionsTarget{Value: m}
+}
+
+type BatchOptionsTarget struct {
+ Value *BatchOptions
+ hintTarget vdl.StringTarget
+ readOnlyTarget vdl.BoolTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *BatchOptionsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*BatchOptions)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *BatchOptionsTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Hint":
+ t.hintTarget.Value = &t.Value.Hint
+ target, err := &t.hintTarget, error(nil)
+ return nil, target, err
+ case "ReadOnly":
+ t.readOnlyTarget.Value = &t.Value.ReadOnly
+ target, err := &t.readOnlyTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.BatchOptions", name)
+ }
+}
+func (t *BatchOptionsTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *BatchOptionsTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *BatchOptionsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BatchOptions{}
+ return nil
+}
+
+// PrefixPermissions represents a pair of (prefix, perms).
+type PrefixPermissions struct {
+ Prefix string
+ Perms access.Permissions
+}
+
+func (PrefixPermissions) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.PrefixPermissions"`
+}) {
+}
+
+func (m *PrefixPermissions) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Prefix")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.Prefix == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Prefix), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Perms")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var7 bool
+ if len(m.Perms) == 0 {
+ var7 = true
+ }
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Perms.FillVDLTarget(fieldTarget6, 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 *PrefixPermissions) MakeVDLTarget() vdl.Target {
+ return &PrefixPermissionsTarget{Value: m}
+}
+
+type PrefixPermissionsTarget struct {
+ Value *PrefixPermissions
+ prefixTarget vdl.StringTarget
+ permsTarget access.PermissionsTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *PrefixPermissionsTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*PrefixPermissions)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *PrefixPermissionsTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Prefix":
+ t.prefixTarget.Value = &t.Value.Prefix
+ target, err := &t.prefixTarget, error(nil)
+ return nil, target, err
+ case "Perms":
+ t.permsTarget.Value = &t.Value.Perms
+ target, err := &t.permsTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.PrefixPermissions", name)
+ }
+}
+func (t *PrefixPermissionsTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *PrefixPermissionsTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *PrefixPermissionsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = PrefixPermissions{}
+ return nil
+}
+
+// KeyValue is a key-value pair.
+type KeyValue struct {
+ Key string
+ Value []byte
+}
+
+func (KeyValue) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.KeyValue"`
+}) {
+}
+
+func (m *KeyValue) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.Key == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Value")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var7 bool
+ if len(m.Value) == 0 {
+ var7 = true
+ }
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget6.FromBytes([]byte(m.Value), 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 *KeyValue) MakeVDLTarget() vdl.Target {
+ return &KeyValueTarget{Value: m}
+}
+
+type KeyValueTarget struct {
+ Value *KeyValue
+ keyTarget vdl.StringTarget
+ valueTarget vdl.BytesTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *KeyValueTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*KeyValue)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *KeyValueTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Key":
+ t.keyTarget.Value = &t.Value.Key
+ target, err := &t.keyTarget, error(nil)
+ return nil, target, err
+ case "Value":
+ t.valueTarget.Value = &t.Value.Value
+ target, err := &t.valueTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.KeyValue", name)
+ }
+}
+func (t *KeyValueTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *KeyValueTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *KeyValueTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = KeyValue{}
+ return nil
+}
+
+// TableRow encapsulates the table name and row key or row prefix.
+type TableRow struct {
+ TableName string
+ Row string
+}
+
+func (TableRow) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.TableRow"`
+}) {
+}
+
+func (m *TableRow) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("TableName")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.TableName == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.TableName), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Row")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var7 := (m.Row == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Row), 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 *TableRow) MakeVDLTarget() vdl.Target {
+ return &TableRowTarget{Value: m}
+}
+
+type TableRowTarget struct {
+ Value *TableRow
+ tableNameTarget vdl.StringTarget
+ rowTarget vdl.StringTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *TableRowTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*TableRow)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *TableRowTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "TableName":
+ t.tableNameTarget.Value = &t.Value.TableName
+ target, err := &t.tableNameTarget, error(nil)
+ return nil, target, err
+ case "Row":
+ t.rowTarget.Value = &t.Value.Row
+ target, err := &t.rowTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.TableRow", name)
+ }
+}
+func (t *TableRowTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *TableRowTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *TableRowTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = TableRow{}
+ return nil
+}
+
+// SyncgroupSpec contains the specification for a syncgroup.
+type SyncgroupSpec struct {
+ // Human-readable description of this syncgroup.
+ Description string
+ // Permissions governing access to this syncgroup.
+ Perms access.Permissions
+ // Data (tableName-rowPrefix pairs) covered by this syncgroup.
+ Prefixes []TableRow
+ // Mount tables at which to advertise this syncgroup, for rendezvous purposes.
+ // (Note that in addition to these mount tables, Syncbase also uses
+ // network-neighborhood-based discovery for rendezvous.)
+ // We expect most clients to specify a single mount table, but we accept an
+ // array of mount tables to permit the mount table to be changed over time
+ // without disruption.
+ // TODO(hpucha): Figure out a convention for advertising syncgroups in the
+ // mount table.
+ MountTables []string
+ // Specifies the privacy of this syncgroup. More specifically, specifies
+ // whether blobs in this syncgroup can be served to clients presenting
+ // blobrefs obtained from other syncgroups.
+ IsPrivate bool
+}
+
+func (SyncgroupSpec) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.SyncgroupSpec"`
+}) {
+}
+
+func (m *SyncgroupSpec) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Description")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.Description == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Description), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Perms")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var7 bool
+ if len(m.Perms) == 0 {
+ var7 = true
+ }
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Perms.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ return err
+ }
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Prefixes")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var10 bool
+ if len(m.Prefixes) == 0 {
+ var10 = true
+ }
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget11, err := fieldTarget9.StartList(tt.NonOptional().Field(2).Type, len(m.Prefixes))
+ if err != nil {
+ return err
+ }
+ for i, elem13 := range m.Prefixes {
+ elemTarget12, err := listTarget11.StartElem(i)
+ if err != nil {
+ return err
+ }
+
+ if err := elem13.FillVDLTarget(elemTarget12, tt.NonOptional().Field(2).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget11.FinishElem(elemTarget12); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget9.FinishList(listTarget11); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
+ return err
+ }
+ }
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("MountTables")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var16 bool
+ if len(m.MountTables) == 0 {
+ var16 = true
+ }
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget17, err := fieldTarget15.StartList(tt.NonOptional().Field(3).Type, len(m.MountTables))
+ if err != nil {
+ return err
+ }
+ for i, elem19 := range m.MountTables {
+ elemTarget18, err := listTarget17.StartElem(i)
+ if err != nil {
+ return err
+ }
+ if err := elemTarget18.FromString(string(elem19), tt.NonOptional().Field(3).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget17.FinishElem(elemTarget18); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget15.FinishList(listTarget17); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
+ return err
+ }
+ }
+ keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("IsPrivate")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var22 := (m.IsPrivate == false)
+ if var22 {
+ if err := fieldTarget21.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget21.FromBool(bool(m.IsPrivate), tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
+ return err
+ }
+ }
+ if err := t.FinishFields(fieldsTarget1); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *SyncgroupSpec) MakeVDLTarget() vdl.Target {
+ return &SyncgroupSpecTarget{Value: m}
+}
+
+type SyncgroupSpecTarget struct {
+ Value *SyncgroupSpec
+ descriptionTarget vdl.StringTarget
+ permsTarget access.PermissionsTarget
+ prefixesTarget __VDLTarget1_list
+ mountTablesTarget vdl.StringSliceTarget
+ isPrivateTarget vdl.BoolTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *SyncgroupSpecTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*SyncgroupSpec)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *SyncgroupSpecTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Description":
+ t.descriptionTarget.Value = &t.Value.Description
+ target, err := &t.descriptionTarget, error(nil)
+ return nil, target, err
+ case "Perms":
+ t.permsTarget.Value = &t.Value.Perms
+ target, err := &t.permsTarget, error(nil)
+ return nil, target, err
+ case "Prefixes":
+ t.prefixesTarget.Value = &t.Value.Prefixes
+ target, err := &t.prefixesTarget, error(nil)
+ return nil, target, err
+ case "MountTables":
+ t.mountTablesTarget.Value = &t.Value.MountTables
+ target, err := &t.mountTablesTarget, error(nil)
+ return nil, target, err
+ case "IsPrivate":
+ t.isPrivateTarget.Value = &t.Value.IsPrivate
+ target, err := &t.isPrivateTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.SyncgroupSpec", name)
+ }
+}
+func (t *SyncgroupSpecTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *SyncgroupSpecTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *SyncgroupSpecTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SyncgroupSpec{}
+ return nil
+}
+
+// []TableRow
+type __VDLTarget1_list struct {
+ Value *[]TableRow
+ elemTarget TableRowTarget
+ vdl.TargetBase
+ vdl.ListTargetBase
+}
+
+func (t *__VDLTarget1_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
+
+ if ttWant := vdl.TypeOf((*[]TableRow)(nil)); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ if cap(*t.Value) < len {
+ *t.Value = make([]TableRow, len)
+ } else {
+ *t.Value = (*t.Value)[:len]
+ }
+ return t, nil
+}
+func (t *__VDLTarget1_list) StartElem(index int) (elem vdl.Target, _ error) {
+ t.elemTarget.Value = &(*t.Value)[index]
+ target, err := &t.elemTarget, error(nil)
+ return target, err
+}
+func (t *__VDLTarget1_list) FinishElem(elem vdl.Target) error {
+ return nil
+}
+func (t *__VDLTarget1_list) FinishList(elem vdl.ListTarget) error {
+
+ return nil
+}
+func (t *__VDLTarget1_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []TableRow(nil)
+ return nil
+}
+
+// SyncgroupMemberInfo contains per-member metadata.
+type SyncgroupMemberInfo struct {
+ SyncPriority byte
+ IsServer bool // This member should be given blob ownership preferentially.
+}
+
+func (SyncgroupMemberInfo) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.SyncgroupMemberInfo"`
+}) {
+}
+
+func (m *SyncgroupMemberInfo) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("SyncPriority")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.SyncPriority == byte(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromUint(uint64(m.SyncPriority), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("IsServer")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var7 := (m.IsServer == false)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromBool(bool(m.IsServer), 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 *SyncgroupMemberInfo) MakeVDLTarget() vdl.Target {
+ return &SyncgroupMemberInfoTarget{Value: m}
+}
+
+type SyncgroupMemberInfoTarget struct {
+ Value *SyncgroupMemberInfo
+ syncPriorityTarget vdl.ByteTarget
+ isServerTarget vdl.BoolTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *SyncgroupMemberInfoTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*SyncgroupMemberInfo)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *SyncgroupMemberInfoTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "SyncPriority":
+ t.syncPriorityTarget.Value = &t.Value.SyncPriority
+ target, err := &t.syncPriorityTarget, error(nil)
+ return nil, target, err
+ case "IsServer":
+ t.isServerTarget.Value = &t.Value.IsServer
+ target, err := &t.isServerTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.SyncgroupMemberInfo", name)
+ }
+}
+func (t *SyncgroupMemberInfoTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *SyncgroupMemberInfoTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *SyncgroupMemberInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SyncgroupMemberInfo{}
+ return nil
+}
+
+// ResolverType defines the possible conflict resolution policies.
+// A Conflict is defined as presence of two independent sets of updates
+// originating from the same version of an object. Syncbase
+// uses version vectors to determine sequence of changes to a given row. Hence
+// if device A updates a row with key "foo" from version V3 to V4, then syncs
+// with device B which further updates the same row from version V4 to V5 and
+// then V5 is synced back to device A, device A will see V5 as a forward
+// progression of "foo" and not a conflict with V3 of "foo". But in the
+// meantime if device A had already updated "foo" again from version V4 to
+// version V6 then there is a conflict between V5 and V6 with V4 being the
+// common ancestor.
+type ResolverType int
+
+const (
+ ResolverTypeLastWins ResolverType = iota
+ ResolverTypeAppResolves
+ ResolverTypeDefer
+)
+
+// ResolverTypeAll holds all labels for ResolverType.
+var ResolverTypeAll = [...]ResolverType{ResolverTypeLastWins, ResolverTypeAppResolves, ResolverTypeDefer}
+
+// ResolverTypeFromString creates a ResolverType from a string label.
+func ResolverTypeFromString(label string) (x ResolverType, err error) {
+ err = x.Set(label)
+ return
+}
+
+// Set assigns label to x.
+func (x *ResolverType) Set(label string) error {
+ switch label {
+ case "LastWins", "lastwins":
+ *x = ResolverTypeLastWins
+ return nil
+ case "AppResolves", "appresolves":
+ *x = ResolverTypeAppResolves
+ return nil
+ case "Defer", "defer":
+ *x = ResolverTypeDefer
+ return nil
+ }
+ *x = -1
+ return fmt.Errorf("unknown label %q in nosql.ResolverType", label)
+}
+
+// String returns the string label of x.
+func (x ResolverType) String() string {
+ switch x {
+ case ResolverTypeLastWins:
+ return "LastWins"
+ case ResolverTypeAppResolves:
+ return "AppResolves"
+ case ResolverTypeDefer:
+ return "Defer"
+ }
+ return ""
+}
+
+func (ResolverType) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.ResolverType"`
+ Enum struct{ LastWins, AppResolves, Defer string }
+}) {
+}
+
+func (m *ResolverType) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ if err := t.FromEnumLabel((*m).String(), tt); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *ResolverType) MakeVDLTarget() vdl.Target {
+ return &ResolverTypeTarget{Value: m}
+}
+
+type ResolverTypeTarget struct {
+ Value *ResolverType
+ vdl.TargetBase
+}
+
+func (t *ResolverTypeTarget) FromEnumLabel(src string, tt *vdl.Type) error {
+
+ if ttWant := vdl.TypeOf((*ResolverType)(nil)); !vdl.Compatible(tt, ttWant) {
+ return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ switch src {
+ case "LastWins":
+ *t.Value = 0
+ case "AppResolves":
+ *t.Value = 1
+ case "Defer":
+ *t.Value = 2
+ default:
+ return fmt.Errorf("label %s not in enum ResolverTypeLastWins", src)
+ }
+
+ return nil
+}
+func (t *ResolverTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ResolverTypeLastWins
+ return nil
+}
+
+// BatchSource represents where the batch was committed.
+type BatchSource int
+
+const (
+ BatchSourceLocal BatchSource = iota
+ BatchSourceRemote
+)
+
+// BatchSourceAll holds all labels for BatchSource.
+var BatchSourceAll = [...]BatchSource{BatchSourceLocal, BatchSourceRemote}
+
+// BatchSourceFromString creates a BatchSource from a string label.
+func BatchSourceFromString(label string) (x BatchSource, err error) {
+ err = x.Set(label)
+ return
+}
+
+// Set assigns label to x.
+func (x *BatchSource) Set(label string) error {
+ switch label {
+ case "Local", "local":
+ *x = BatchSourceLocal
+ return nil
+ case "Remote", "remote":
+ *x = BatchSourceRemote
+ return nil
+ }
+ *x = -1
+ return fmt.Errorf("unknown label %q in nosql.BatchSource", label)
+}
+
+// String returns the string label of x.
+func (x BatchSource) String() string {
+ switch x {
+ case BatchSourceLocal:
+ return "Local"
+ case BatchSourceRemote:
+ return "Remote"
+ }
+ return ""
+}
+
+func (BatchSource) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.BatchSource"`
+ Enum struct{ Local, Remote string }
+}) {
+}
+
+func (m *BatchSource) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ if err := t.FromEnumLabel((*m).String(), tt); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *BatchSource) MakeVDLTarget() vdl.Target {
+ return &BatchSourceTarget{Value: m}
+}
+
+type BatchSourceTarget struct {
+ Value *BatchSource
+ vdl.TargetBase
+}
+
+func (t *BatchSourceTarget) FromEnumLabel(src string, tt *vdl.Type) error {
+
+ if ttWant := vdl.TypeOf((*BatchSource)(nil)); !vdl.Compatible(tt, ttWant) {
+ return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ switch src {
+ case "Local":
+ *t.Value = 0
+ case "Remote":
+ *t.Value = 1
+ default:
+ return fmt.Errorf("label %s not in enum BatchSourceLocal", src)
+ }
+
+ return nil
+}
+func (t *BatchSourceTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BatchSourceLocal
+ return nil
+}
+
+type BatchInfo struct {
+ // Id is an identifier for a batch contained in a conflict. It is
+ // unique only in the context of a given conflict. Its purpose is solely to
+ // group one or more RowInfo objects together to represent a batch that
+ // was committed by the client.
+ Id uint64
+ // Hint is the hint provided by the client when this batch was committed.
+ Hint string
+ // Source states where the batch comes from.
+ Source BatchSource
+}
+
+func (BatchInfo) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.BatchInfo"`
+}) {
+}
+
+func (m *BatchInfo) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Id")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.Id == uint64(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromUint(uint64(m.Id), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Hint")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var7 := (m.Hint == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Hint), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ return err
+ }
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Source")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var10 := (m.Source == BatchSourceLocal)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Source.FillVDLTarget(fieldTarget9, 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 *BatchInfo) MakeVDLTarget() vdl.Target {
+ return &BatchInfoTarget{Value: m}
+}
+
+type BatchInfoTarget struct {
+ Value *BatchInfo
+ idTarget vdl.Uint64Target
+ hintTarget vdl.StringTarget
+ sourceTarget BatchSourceTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *BatchInfoTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*BatchInfo)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *BatchInfoTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Id":
+ t.idTarget.Value = &t.Value.Id
+ target, err := &t.idTarget, error(nil)
+ return nil, target, err
+ case "Hint":
+ t.hintTarget.Value = &t.Value.Hint
+ target, err := &t.hintTarget, error(nil)
+ return nil, target, err
+ case "Source":
+ t.sourceTarget.Value = &t.Value.Source
+ target, err := &t.sourceTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.BatchInfo", name)
+ }
+}
+func (t *BatchInfoTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *BatchInfoTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *BatchInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BatchInfo{}
+ return nil
+}
+
+// ValueState represents the state for Value object providing information about
+// whether the Value object's Byte field is empty or not.
+type ValueState int
+
+const (
+ ValueStateExists ValueState = iota
+ ValueStateNoExists
+ ValueStateDeleted
+ ValueStateUnknown
+)
+
+// ValueStateAll holds all labels for ValueState.
+var ValueStateAll = [...]ValueState{ValueStateExists, ValueStateNoExists, ValueStateDeleted, ValueStateUnknown}
+
+// ValueStateFromString creates a ValueState from a string label.
+func ValueStateFromString(label string) (x ValueState, err error) {
+ err = x.Set(label)
+ return
+}
+
+// Set assigns label to x.
+func (x *ValueState) Set(label string) error {
+ switch label {
+ case "Exists", "exists":
+ *x = ValueStateExists
+ return nil
+ case "NoExists", "noexists":
+ *x = ValueStateNoExists
+ return nil
+ case "Deleted", "deleted":
+ *x = ValueStateDeleted
+ return nil
+ case "Unknown", "unknown":
+ *x = ValueStateUnknown
+ return nil
+ }
+ *x = -1
+ return fmt.Errorf("unknown label %q in nosql.ValueState", label)
+}
+
+// String returns the string label of x.
+func (x ValueState) String() string {
+ switch x {
+ case ValueStateExists:
+ return "Exists"
+ case ValueStateNoExists:
+ return "NoExists"
+ case ValueStateDeleted:
+ return "Deleted"
+ case ValueStateUnknown:
+ return "Unknown"
+ }
+ return ""
+}
+
+func (ValueState) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.ValueState"`
+ Enum struct{ Exists, NoExists, Deleted, Unknown string }
+}) {
+}
+
+func (m *ValueState) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ if err := t.FromEnumLabel((*m).String(), tt); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *ValueState) MakeVDLTarget() vdl.Target {
+ return &ValueStateTarget{Value: m}
+}
+
+type ValueStateTarget struct {
+ Value *ValueState
+ vdl.TargetBase
+}
+
+func (t *ValueStateTarget) FromEnumLabel(src string, tt *vdl.Type) error {
+
+ if ttWant := vdl.TypeOf((*ValueState)(nil)); !vdl.Compatible(tt, ttWant) {
+ return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ switch src {
+ case "Exists":
+ *t.Value = 0
+ case "NoExists":
+ *t.Value = 1
+ case "Deleted":
+ *t.Value = 2
+ case "Unknown":
+ *t.Value = 3
+ default:
+ return fmt.Errorf("label %s not in enum ValueStateExists", src)
+ }
+
+ return nil
+}
+func (t *ValueStateTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ValueStateExists
+ return nil
+}
+
+// Value contains the encoded bytes for a row's value stored in syncbase.
+type Value struct {
+ // State provides information about whether the field Bytes is empty or
+ // not and if it is empty then why.
+ State ValueState
+ // VOM encoded bytes for a row's value or nil if the row was deleted.
+ Bytes []byte
+ // Write timestamp for this value
+ WriteTs time.Time
+}
+
+func (Value) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.Value"`
+}) {
+}
+
+func (m *Value) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("State")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.State == ValueStateExists)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Bytes")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var7 bool
+ if len(m.Bytes) == 0 {
+ var7 = true
+ }
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget6.FromBytes([]byte(m.Bytes), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ return err
+ }
+ }
+ var wireValue8 time_2.Time
+ if err := time_2.TimeFromNative(&wireValue8, m.WriteTs); err != nil {
+ return err
+ }
+
+ keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("WriteTs")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var11 := (wireValue8 == time_2.Time{})
+ if var11 {
+ if err := fieldTarget10.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ 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 *Value) MakeVDLTarget() vdl.Target {
+ return &ValueTarget{Value: m}
+}
+
+type ValueTarget struct {
+ Value *Value
+ stateTarget ValueStateTarget
+ bytesTarget vdl.BytesTarget
+ writeTsTarget time_2.TimeTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *ValueTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*Value)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *ValueTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "State":
+ t.stateTarget.Value = &t.Value.State
+ target, err := &t.stateTarget, error(nil)
+ return nil, target, err
+ case "Bytes":
+ t.bytesTarget.Value = &t.Value.Bytes
+ target, err := &t.bytesTarget, error(nil)
+ return nil, target, err
+ case "WriteTs":
+ t.writeTsTarget.Value = &t.Value.WriteTs
+ target, err := &t.writeTsTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.Value", name)
+ }
+}
+func (t *ValueTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *ValueTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *ValueTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Value{}
+ return nil
+}
+
+// RowOp represents a read or write operation on a row corresponding to the
+// given key.
+type RowOp struct {
+ // The key under conflict.
+ Key string
+ // LocalValue contains the value read or written by local syncbase or nil.
+ LocalValue *Value
+ // RemoteValue contains the value read or written by remote syncbase or nil.
+ RemoteValue *Value
+ // AncestorValue contains the value for the key which is the lowest common
+ // ancestor of the two values represented by LocalValue and RemoteValue or
+ // nil if no ancestor exists or if the operation was read.
+ AncestorValue *Value
+}
+
+func (RowOp) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.RowOp"`
+}) {
+}
+
+func (m *RowOp) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.Key == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("LocalValue")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var7 := (m.LocalValue == (*Value)(nil))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.LocalValue.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ return err
+ }
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("RemoteValue")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var10 := (m.RemoteValue == (*Value)(nil))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.RemoteValue.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
+ return err
+ }
+ }
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("AncestorValue")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var13 := (m.AncestorValue == (*Value)(nil))
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.AncestorValue.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
+ if err := t.FinishFields(fieldsTarget1); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *RowOp) MakeVDLTarget() vdl.Target {
+ return &RowOpTarget{Value: m}
+}
+
+type RowOpTarget struct {
+ Value *RowOp
+ keyTarget vdl.StringTarget
+ localValueTarget __VDLTarget2_optional
+ remoteValueTarget __VDLTarget2_optional
+ ancestorValueTarget __VDLTarget2_optional
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *RowOpTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*RowOp)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *RowOpTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Key":
+ t.keyTarget.Value = &t.Value.Key
+ target, err := &t.keyTarget, error(nil)
+ return nil, target, err
+ case "LocalValue":
+ t.localValueTarget.Value = &t.Value.LocalValue
+ target, err := &t.localValueTarget, error(nil)
+ return nil, target, err
+ case "RemoteValue":
+ t.remoteValueTarget.Value = &t.Value.RemoteValue
+ target, err := &t.remoteValueTarget, error(nil)
+ return nil, target, err
+ case "AncestorValue":
+ t.ancestorValueTarget.Value = &t.Value.AncestorValue
+ target, err := &t.ancestorValueTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.RowOp", name)
+ }
+}
+func (t *RowOpTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *RowOpTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *RowOpTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = RowOp{}
+ return nil
+}
+
+// Optional Value
+type __VDLTarget2_optional struct {
+ Value **Value
+ elemTarget ValueTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *__VDLTarget2_optional) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if *t.Value == nil {
+ *t.Value = &Value{}
+ }
+ t.elemTarget.Value = *t.Value
+ target, err := &t.elemTarget, error(nil)
+ if err != nil {
+ return nil, err
+ }
+ return target.StartFields(tt)
+}
+func (t *__VDLTarget2_optional) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *__VDLTarget2_optional) FromZero(tt *vdl.Type) error {
+ *t.Value = (*Value)(nil)
+ return nil
+}
+
+// ScanOp provides details of a scan operation.
+type ScanOp struct {
+ // Start contains the starting key for a range scan.
+ Start string
+ // Limit contains the end key for a range scan.
+ Limit string
+}
+
+func (ScanOp) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.ScanOp"`
+}) {
+}
+
+func (m *ScanOp) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Start")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.Start == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Start), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Limit")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var7 := (m.Limit == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Limit), 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 *ScanOp) MakeVDLTarget() vdl.Target {
+ return &ScanOpTarget{Value: m}
+}
+
+type ScanOpTarget struct {
+ Value *ScanOp
+ startTarget vdl.StringTarget
+ limitTarget vdl.StringTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *ScanOpTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*ScanOp)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *ScanOpTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Start":
+ t.startTarget.Value = &t.Value.Start
+ target, err := &t.startTarget, error(nil)
+ return nil, target, err
+ case "Limit":
+ t.limitTarget.Value = &t.Value.Limit
+ target, err := &t.limitTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.ScanOp", name)
+ }
+}
+func (t *ScanOpTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *ScanOpTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *ScanOpTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ScanOp{}
+ return nil
+}
+
+type (
+ // Operation represents any single field of the Operation union type.
+ //
+ // Operation represents a specific operation on a row or a set of rows that is
+ // a part of the conflict.
+ Operation interface {
+ // Index returns the field index.
+ Index() int
+ // Interface returns the field value as an interface.
+ Interface() interface{}
+ // Name returns the field name.
+ Name() string
+ // __VDLReflect describes the Operation union type.
+ __VDLReflect(__OperationReflect)
+ FillVDLTarget(vdl.Target, *vdl.Type) error
+ }
+ // OperationRead represents field Read of the Operation union type.
+ //
+ // Read represents a read operation performed on a specific row. For a given
+ // row key there can only be at max one Read operation within a conflict.
+ OperationRead struct{ Value RowOp }
+ // OperationWrite represents field Write of the Operation union type.
+ //
+ // Write represents a write operation performed on a specific row. For a
+ // given row key there can only be at max one Write operation within a
+ // conflict.
+ OperationWrite struct{ Value RowOp }
+ // OperationScan represents field Scan of the Operation union type.
+ //
+ // Scan represents a scan operation performed over a specific range of keys.
+ // For a given key range there can be at max one ScanOp within the Conflict.
+ OperationScan struct{ Value ScanOp }
+ // __OperationReflect describes the Operation union type.
+ __OperationReflect struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.Operation"`
+ Type Operation
+ UnionTargetFactory operationTargetFactory
+ Union struct {
+ Read OperationRead
+ Write OperationWrite
+ Scan OperationScan
+ }
+ }
+)
+
+func (x OperationRead) Index() int { return 0 }
+func (x OperationRead) Interface() interface{} { return x.Value }
+func (x OperationRead) Name() string { return "Read" }
+func (x OperationRead) __VDLReflect(__OperationReflect) {}
+
+func (m OperationRead) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Read")
+ if err != nil {
+ return err
+ }
+
+ if err := m.Value.FillVDLTarget(fieldTarget3, 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 OperationRead) MakeVDLTarget() vdl.Target {
+ return nil
+}
+
+func (x OperationWrite) Index() int { return 1 }
+func (x OperationWrite) Interface() interface{} { return x.Value }
+func (x OperationWrite) Name() string { return "Write" }
+func (x OperationWrite) __VDLReflect(__OperationReflect) {}
+
+func (m OperationWrite) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Write")
+ if err != nil {
+ return err
+ }
+
+ if err := m.Value.FillVDLTarget(fieldTarget3, 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 OperationWrite) MakeVDLTarget() vdl.Target {
+ return nil
+}
+
+func (x OperationScan) Index() int { return 2 }
+func (x OperationScan) Interface() interface{} { return x.Value }
+func (x OperationScan) Name() string { return "Scan" }
+func (x OperationScan) __VDLReflect(__OperationReflect) {}
+
+func (m OperationScan) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Scan")
+ if err != nil {
+ return err
+ }
+
+ if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(2).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 OperationScan) MakeVDLTarget() vdl.Target {
+ return nil
+}
+
+type OperationTarget struct {
+ Value *Operation
+ fieldName string
+
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *OperationTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+ if ttWant := vdl.TypeOf((*Operation)(nil)); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+
+ return t, nil
+}
+func (t *OperationTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ t.fieldName = name
+ switch name {
+ case "Read":
+ val := RowOp{}
+ return nil, &RowOpTarget{Value: &val}, nil
+ case "Write":
+ val := RowOp{}
+ return nil, &RowOpTarget{Value: &val}, nil
+ case "Scan":
+ val := ScanOp{}
+ return nil, &ScanOpTarget{Value: &val}, nil
+ default:
+ return nil, nil, fmt.Errorf("field %s not in union v.io/v23/services/syncbase/nosql.Operation", name)
+ }
+}
+func (t *OperationTarget) FinishField(_, fieldTarget vdl.Target) error {
+ switch t.fieldName {
+ case "Read":
+ *t.Value = OperationRead{*(fieldTarget.(*RowOpTarget)).Value}
+ case "Write":
+ *t.Value = OperationWrite{*(fieldTarget.(*RowOpTarget)).Value}
+ case "Scan":
+ *t.Value = OperationScan{*(fieldTarget.(*ScanOpTarget)).Value}
+ }
+ return nil
+}
+func (t *OperationTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *OperationTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Operation(OperationRead{})
+ return nil
+}
+
+type operationTargetFactory struct{}
+
+func (t operationTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
+ if typedUnion, ok := union.(*Operation); ok {
+ return &OperationTarget{Value: typedUnion}, nil
+ }
+ return nil, fmt.Errorf("got %T, want *Operation", union)
+}
+
+// RowInfo contains a single operation performed on a row (in case of read or
+// write) or a range or rows (in case of scan) along with a mapping to each
+// of the batches that this operation belongs to.
+// For example, if Row1 was updated on local syncbase conflicting with a write
+// on remote syncbase as part of two separate batches, then it will be
+// represented by a single RowInfo with Write Operation containing the
+// respective local and remote values along with the batch id for both batches
+// stored in the BatchIds field.
+type RowInfo struct {
+ // Op is a specific operation represented by RowInfo
+ Op Operation
+ // BatchIds contains ids of all batches that this RowInfo is a part of.
+ BatchIds []uint64
+}
+
+func (RowInfo) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.RowInfo"`
+}) {
+}
+
+func (m *RowInfo) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Op")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var4 bool
+ if field, ok := m.Op.(OperationRead); ok {
+
+ var5 := true
+ var6 := (field.Value.Key == "")
+ var5 = var5 && var6
+ var7 := (field.Value.LocalValue == (*Value)(nil))
+ var5 = var5 && var7
+ var8 := (field.Value.RemoteValue == (*Value)(nil))
+ var5 = var5 && var8
+ var9 := (field.Value.AncestorValue == (*Value)(nil))
+ var5 = var5 && var9
+ var4 = var5
+ }
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ unionValue10 := m.Op
+ if unionValue10 == nil {
+ unionValue10 = OperationRead{}
+ }
+ if err := unionValue10.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("BatchIds")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var13 bool
+ if len(m.BatchIds) == 0 {
+ var13 = true
+ }
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget14, err := fieldTarget12.StartList(tt.NonOptional().Field(1).Type, len(m.BatchIds))
+ if err != nil {
+ return err
+ }
+ for i, elem16 := range m.BatchIds {
+ elemTarget15, err := listTarget14.StartElem(i)
+ if err != nil {
+ return err
+ }
+ if err := elemTarget15.FromUint(uint64(elem16), tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget14.FinishElem(elemTarget15); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget12.FinishList(listTarget14); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
+ if err := t.FinishFields(fieldsTarget1); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *RowInfo) MakeVDLTarget() vdl.Target {
+ return &RowInfoTarget{Value: m}
+}
+
+type RowInfoTarget struct {
+ Value *RowInfo
+ opTarget OperationTarget
+ batchIdsTarget __VDLTarget3_list
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *RowInfoTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*RowInfo)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *RowInfoTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Op":
+ t.opTarget.Value = &t.Value.Op
+ target, err := &t.opTarget, error(nil)
+ return nil, target, err
+ case "BatchIds":
+ t.batchIdsTarget.Value = &t.Value.BatchIds
+ target, err := &t.batchIdsTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.RowInfo", name)
+ }
+}
+func (t *RowInfoTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *RowInfoTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *RowInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = RowInfo{
+ Op: OperationRead{},
+ }
+ return nil
+}
+
+// []uint64
+type __VDLTarget3_list struct {
+ Value *[]uint64
+ elemTarget vdl.Uint64Target
+ vdl.TargetBase
+ vdl.ListTargetBase
+}
+
+func (t *__VDLTarget3_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
+
+ if ttWant := vdl.TypeOf((*[]uint64)(nil)); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ if cap(*t.Value) < len {
+ *t.Value = make([]uint64, len)
+ } else {
+ *t.Value = (*t.Value)[:len]
+ }
+ return t, nil
+}
+func (t *__VDLTarget3_list) StartElem(index int) (elem vdl.Target, _ error) {
+ t.elemTarget.Value = &(*t.Value)[index]
+ target, err := &t.elemTarget, error(nil)
+ return target, err
+}
+func (t *__VDLTarget3_list) FinishElem(elem vdl.Target) error {
+ return nil
+}
+func (t *__VDLTarget3_list) FinishList(elem vdl.ListTarget) error {
+
+ return nil
+}
+func (t *__VDLTarget3_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []uint64(nil)
+ return nil
+}
+
+type (
+ // ConflictData represents any single field of the ConflictData union type.
+ //
+ // ConflictData represents a unit of conflict data sent over the stream. It
+ // can either contain information about a Batch or about an operation done
+ // on a row.
+ ConflictData interface {
+ // Index returns the field index.
+ Index() int
+ // Interface returns the field value as an interface.
+ Interface() interface{}
+ // Name returns the field name.
+ Name() string
+ // __VDLReflect describes the ConflictData union type.
+ __VDLReflect(__ConflictDataReflect)
+ FillVDLTarget(vdl.Target, *vdl.Type) error
+ }
+ // ConflictDataBatch represents field Batch of the ConflictData union type.
+ ConflictDataBatch struct{ Value BatchInfo }
+ // ConflictDataRow represents field Row of the ConflictData union type.
+ ConflictDataRow struct{ Value RowInfo }
+ // __ConflictDataReflect describes the ConflictData union type.
+ __ConflictDataReflect struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.ConflictData"`
+ Type ConflictData
+ UnionTargetFactory conflictDataTargetFactory
+ Union struct {
+ Batch ConflictDataBatch
+ Row ConflictDataRow
+ }
+ }
+)
+
+func (x ConflictDataBatch) Index() int { return 0 }
+func (x ConflictDataBatch) Interface() interface{} { return x.Value }
+func (x ConflictDataBatch) Name() string { return "Batch" }
+func (x ConflictDataBatch) __VDLReflect(__ConflictDataReflect) {}
+
+func (m ConflictDataBatch) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Batch")
+ if err != nil {
+ return err
+ }
+
+ if err := m.Value.FillVDLTarget(fieldTarget3, 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 ConflictDataBatch) MakeVDLTarget() vdl.Target {
+ return nil
+}
+
+func (x ConflictDataRow) Index() int { return 1 }
+func (x ConflictDataRow) Interface() interface{} { return x.Value }
+func (x ConflictDataRow) Name() string { return "Row" }
+func (x ConflictDataRow) __VDLReflect(__ConflictDataReflect) {}
+
+func (m ConflictDataRow) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Row")
+ if err != nil {
+ return err
+ }
+
+ if err := m.Value.FillVDLTarget(fieldTarget3, 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 ConflictDataRow) MakeVDLTarget() vdl.Target {
+ return nil
+}
+
+type ConflictDataTarget struct {
+ Value *ConflictData
+ fieldName string
+
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *ConflictDataTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+ if ttWant := vdl.TypeOf((*ConflictData)(nil)); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+
+ return t, nil
+}
+func (t *ConflictDataTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ t.fieldName = name
+ switch name {
+ case "Batch":
+ val := BatchInfo{}
+ return nil, &BatchInfoTarget{Value: &val}, nil
+ case "Row":
+ val := RowInfo{
+ Op: OperationRead{},
+ }
+ return nil, &RowInfoTarget{Value: &val}, nil
+ default:
+ return nil, nil, fmt.Errorf("field %s not in union v.io/v23/services/syncbase/nosql.ConflictData", name)
+ }
+}
+func (t *ConflictDataTarget) FinishField(_, fieldTarget vdl.Target) error {
+ switch t.fieldName {
+ case "Batch":
+ *t.Value = ConflictDataBatch{*(fieldTarget.(*BatchInfoTarget)).Value}
+ case "Row":
+ *t.Value = ConflictDataRow{*(fieldTarget.(*RowInfoTarget)).Value}
+ }
+ return nil
+}
+func (t *ConflictDataTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *ConflictDataTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ConflictData(ConflictDataBatch{})
+ return nil
+}
+
+type conflictDataTargetFactory struct{}
+
+func (t conflictDataTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
+ if typedUnion, ok := union.(*ConflictData); ok {
+ return &ConflictDataTarget{Value: typedUnion}, nil
+ }
+ return nil, fmt.Errorf("got %T, want *ConflictData", union)
+}
+
+// ConflictInfo contains information to fully specify a conflict
+// for a key, providing the (local, remote, ancestor) tuple.
+// A key under conflict can be a part of a batch in local, remote or both
+// updates. Since the batches can have more than one key, all ConflictInfos
+// for the keys within the batches are grouped together into a single conflict
+// batch and sent as a stream with the Continued field representing conflict
+// batch boundaries.
+type ConflictInfo struct {
+ // Data is a unit chunk of ConflictInfo which can be sent over the conflict
+ // stream.
+ Data ConflictData
+ // Continued represents whether the batch of ConflictInfos has ended.
+ Continued bool
+}
+
+func (ConflictInfo) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.ConflictInfo"`
+}) {
+}
+
+func (m *ConflictInfo) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Data")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var4 bool
+ if field, ok := m.Data.(ConflictDataBatch); ok {
+
+ var5 := (field.Value == BatchInfo{})
+ var4 = var5
+ }
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ unionValue6 := m.Data
+ if unionValue6 == nil {
+ unionValue6 = ConflictDataBatch{}
+ }
+ if err := unionValue6.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("Continued")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var9 := (m.Continued == false)
+ if var9 {
+ if err := fieldTarget8.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget8.FromBool(bool(m.Continued), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
+ return err
+ }
+ }
+ if err := t.FinishFields(fieldsTarget1); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *ConflictInfo) MakeVDLTarget() vdl.Target {
+ return &ConflictInfoTarget{Value: m}
+}
+
+type ConflictInfoTarget struct {
+ Value *ConflictInfo
+ dataTarget ConflictDataTarget
+ continuedTarget vdl.BoolTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *ConflictInfoTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*ConflictInfo)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *ConflictInfoTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Data":
+ t.dataTarget.Value = &t.Value.Data
+ target, err := &t.dataTarget, error(nil)
+ return nil, target, err
+ case "Continued":
+ t.continuedTarget.Value = &t.Value.Continued
+ target, err := &t.continuedTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.ConflictInfo", name)
+ }
+}
+func (t *ConflictInfoTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *ConflictInfoTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *ConflictInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ConflictInfo{
+ Data: ConflictDataBatch{},
+ }
+ return nil
+}
+
+// ValueSelection represents the value that was selected as the final resolution
+// for a conflict.
+type ValueSelection int
+
+const (
+ ValueSelectionLocal ValueSelection = iota
+ ValueSelectionRemote
+ ValueSelectionOther
+)
+
+// ValueSelectionAll holds all labels for ValueSelection.
+var ValueSelectionAll = [...]ValueSelection{ValueSelectionLocal, ValueSelectionRemote, ValueSelectionOther}
+
+// ValueSelectionFromString creates a ValueSelection from a string label.
+func ValueSelectionFromString(label string) (x ValueSelection, err error) {
+ err = x.Set(label)
+ return
+}
+
+// Set assigns label to x.
+func (x *ValueSelection) Set(label string) error {
+ switch label {
+ case "Local", "local":
+ *x = ValueSelectionLocal
+ return nil
+ case "Remote", "remote":
+ *x = ValueSelectionRemote
+ return nil
+ case "Other", "other":
+ *x = ValueSelectionOther
+ return nil
+ }
+ *x = -1
+ return fmt.Errorf("unknown label %q in nosql.ValueSelection", label)
+}
+
+// String returns the string label of x.
+func (x ValueSelection) String() string {
+ switch x {
+ case ValueSelectionLocal:
+ return "Local"
+ case ValueSelectionRemote:
+ return "Remote"
+ case ValueSelectionOther:
+ return "Other"
+ }
+ return ""
+}
+
+func (ValueSelection) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.ValueSelection"`
+ Enum struct{ Local, Remote, Other string }
+}) {
+}
+
+func (m *ValueSelection) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ if err := t.FromEnumLabel((*m).String(), tt); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *ValueSelection) MakeVDLTarget() vdl.Target {
+ return &ValueSelectionTarget{Value: m}
+}
+
+type ValueSelectionTarget struct {
+ Value *ValueSelection
+ vdl.TargetBase
+}
+
+func (t *ValueSelectionTarget) FromEnumLabel(src string, tt *vdl.Type) error {
+
+ if ttWant := vdl.TypeOf((*ValueSelection)(nil)); !vdl.Compatible(tt, ttWant) {
+ return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ switch src {
+ case "Local":
+ *t.Value = 0
+ case "Remote":
+ *t.Value = 1
+ case "Other":
+ *t.Value = 2
+ default:
+ return fmt.Errorf("label %s not in enum ValueSelectionLocal", src)
+ }
+
+ return nil
+}
+func (t *ValueSelectionTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ValueSelectionLocal
+ return nil
+}
+
+// ResolutionInfo contains the application’s reply to a conflict for a key,
+// providing the resolution value. The resolution may be over a group of keys
+// in which case the application must send a stream of ResolutionInfos with
+// the Continued field for the last ResolutionInfo representing the end of the
+// batch with a value false. ResolutionInfos sent as part of a batch will be
+// committed as a batch. If the commit fails, the Conflict will be re-sent.
+type ResolutionInfo struct {
+ // Key is the key under conflict.
+ Key string
+ // Selection represents the value that was selected as resolution.
+ Selection ValueSelection
+ // Result is the resolved value for the key. This field should be used only
+ // if value of Selection field is 'Other'. If the result of a resolution is
+ // delete for this key then add Value with nil Bytes.
+ Result *Value
+ // Continued represents whether the batch of ResolutionInfos has ended.
+ Continued bool
+}
+
+func (ResolutionInfo) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.ResolutionInfo"`
+}) {
+}
+
+func (m *ResolutionInfo) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.Key == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Selection")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var7 := (m.Selection == ValueSelectionLocal)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Selection.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ return err
+ }
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Result")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var10 := (m.Result == (*Value)(nil))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Result.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
+ return err
+ }
+ }
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Continued")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var13 := (m.Continued == false)
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget12.FromBool(bool(m.Continued), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
+ if err := t.FinishFields(fieldsTarget1); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *ResolutionInfo) MakeVDLTarget() vdl.Target {
+ return &ResolutionInfoTarget{Value: m}
+}
+
+type ResolutionInfoTarget struct {
+ Value *ResolutionInfo
+ keyTarget vdl.StringTarget
+ selectionTarget ValueSelectionTarget
+ resultTarget __VDLTarget2_optional
+ continuedTarget vdl.BoolTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *ResolutionInfoTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*ResolutionInfo)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *ResolutionInfoTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Key":
+ t.keyTarget.Value = &t.Value.Key
+ target, err := &t.keyTarget, error(nil)
+ return nil, target, err
+ case "Selection":
+ t.selectionTarget.Value = &t.Value.Selection
+ target, err := &t.selectionTarget, error(nil)
+ return nil, target, err
+ case "Result":
+ t.resultTarget.Value = &t.Value.Result
+ target, err := &t.resultTarget, error(nil)
+ return nil, target, err
+ case "Continued":
+ t.continuedTarget.Value = &t.Value.Continued
+ target, err := &t.continuedTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.ResolutionInfo", name)
+ }
+}
+func (t *ResolutionInfoTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *ResolutionInfoTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *ResolutionInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ResolutionInfo{}
+ return nil
+}
+
+// CrRule provides a filter and the type of resolution to perform for a row
+// under conflict that passes the filter.
+type CrRule struct {
+ // TableName is the name of the table that this rule applies to.
+ TableName string
+ // KeyPrefix represents the set of keys within the given table for which
+ // this policy applies. TableName must not be empty if this field is set.
+ KeyPrefix string
+ // Type includes the full package path for the value type for which this
+ // policy applies.
+ Type string
+ // Policy for resolving conflict.
+ Resolver ResolverType
+}
+
+func (CrRule) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.CrRule"`
+}) {
+}
+
+func (m *CrRule) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("TableName")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.TableName == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.TableName), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("KeyPrefix")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var7 := (m.KeyPrefix == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.KeyPrefix), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ return err
+ }
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Type")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var10 := (m.Type == "")
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromString(string(m.Type), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
+ return err
+ }
+ }
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Resolver")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var13 := (m.Resolver == ResolverTypeLastWins)
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Resolver.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
+ if err := t.FinishFields(fieldsTarget1); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *CrRule) MakeVDLTarget() vdl.Target {
+ return &CrRuleTarget{Value: m}
+}
+
+type CrRuleTarget struct {
+ Value *CrRule
+ tableNameTarget vdl.StringTarget
+ keyPrefixTarget vdl.StringTarget
+ typeTarget vdl.StringTarget
+ resolverTarget ResolverTypeTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *CrRuleTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*CrRule)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *CrRuleTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "TableName":
+ t.tableNameTarget.Value = &t.Value.TableName
+ target, err := &t.tableNameTarget, error(nil)
+ return nil, target, err
+ case "KeyPrefix":
+ t.keyPrefixTarget.Value = &t.Value.KeyPrefix
+ target, err := &t.keyPrefixTarget, error(nil)
+ return nil, target, err
+ case "Type":
+ t.typeTarget.Value = &t.Value.Type
+ target, err := &t.typeTarget, error(nil)
+ return nil, target, err
+ case "Resolver":
+ t.resolverTarget.Value = &t.Value.Resolver
+ target, err := &t.resolverTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.CrRule", name)
+ }
+}
+func (t *CrRuleTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *CrRuleTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *CrRuleTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = CrRule{}
+ return nil
+}
+
+// For a given row with a conflict, all rules are matched against the row.
+// If no rules match the row, we default to "LastWins". If multiple
+// rules match the row, ties are broken as follows:
+// 1. If one match has a longer prefix than the other, take that one.
+// 2. Else, if only one match specifies a type, take that one.
+// 3. Else, the two matches are identical; take the last one in the Rules array.
+type CrPolicy struct {
+ Rules []CrRule
+}
+
+func (CrPolicy) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.CrPolicy"`
+}) {
+}
+
+func (m *CrPolicy) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rules")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var4 bool
+ if len(m.Rules) == 0 {
+ var4 = true
+ }
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget5, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.Rules))
+ if err != nil {
+ return err
+ }
+ for i, elem7 := range m.Rules {
+ elemTarget6, err := listTarget5.StartElem(i)
+ if err != nil {
+ return err
+ }
+
+ if err := elem7.FillVDLTarget(elemTarget6, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget5.FinishElem(elemTarget6); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishList(listTarget5); 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 *CrPolicy) MakeVDLTarget() vdl.Target {
+ return &CrPolicyTarget{Value: m}
+}
+
+type CrPolicyTarget struct {
+ Value *CrPolicy
+ rulesTarget __VDLTarget4_list
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *CrPolicyTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*CrPolicy)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *CrPolicyTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Rules":
+ t.rulesTarget.Value = &t.Value.Rules
+ target, err := &t.rulesTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.CrPolicy", name)
+ }
+}
+func (t *CrPolicyTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *CrPolicyTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *CrPolicyTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = CrPolicy{}
+ return nil
+}
+
+// []CrRule
+type __VDLTarget4_list struct {
+ Value *[]CrRule
+ elemTarget CrRuleTarget
+ vdl.TargetBase
+ vdl.ListTargetBase
+}
+
+func (t *__VDLTarget4_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
+
+ if ttWant := vdl.TypeOf((*[]CrRule)(nil)); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ if cap(*t.Value) < len {
+ *t.Value = make([]CrRule, len)
+ } else {
+ *t.Value = (*t.Value)[:len]
+ }
+ return t, nil
+}
+func (t *__VDLTarget4_list) StartElem(index int) (elem vdl.Target, _ error) {
+ t.elemTarget.Value = &(*t.Value)[index]
+ target, err := &t.elemTarget, error(nil)
+ return target, err
+}
+func (t *__VDLTarget4_list) FinishElem(elem vdl.Target) error {
+ return nil
+}
+func (t *__VDLTarget4_list) FinishList(elem vdl.ListTarget) error {
+
+ return nil
+}
+func (t *__VDLTarget4_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []CrRule(nil)
+ return nil
+}
+
+// SchemaMetadata maintains metadata related to the schema of a given database.
+// There is one SchemaMetadata per database.
+type SchemaMetadata struct {
+ // Non negative Schema version number. Should be increased with every schema change
+ // (e.g. adding fields to structs) that cannot be handled by previous
+ // versions of the app.
+ Version int32
+ Policy CrPolicy
+}
+
+func (SchemaMetadata) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.SchemaMetadata"`
+}) {
+}
+
+func (m *SchemaMetadata) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Version")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.Version == int32(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromInt(int64(m.Version), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Policy")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var7 := true
+ var var8 bool
+ if len(m.Policy.Rules) == 0 {
+ var8 = true
+ }
+ var7 = var7 && var8
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Policy.FillVDLTarget(fieldTarget6, 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 *SchemaMetadata) MakeVDLTarget() vdl.Target {
+ return &SchemaMetadataTarget{Value: m}
+}
+
+type SchemaMetadataTarget struct {
+ Value *SchemaMetadata
+ versionTarget vdl.Int32Target
+ policyTarget CrPolicyTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *SchemaMetadataTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*SchemaMetadata)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *SchemaMetadataTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Version":
+ t.versionTarget.Value = &t.Value.Version
+ target, err := &t.versionTarget, error(nil)
+ return nil, target, err
+ case "Policy":
+ t.policyTarget.Value = &t.Value.Policy
+ target, err := &t.policyTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.SchemaMetadata", name)
+ }
+}
+func (t *SchemaMetadataTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *SchemaMetadataTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *SchemaMetadataTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SchemaMetadata{}
+ return nil
+}
+
+// BlobRef is a reference to a blob.
+type BlobRef string
+
+func (BlobRef) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.BlobRef"`
+}) {
+}
+
+func (m *BlobRef) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ if err := t.FromString(string((*m)), tt); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *BlobRef) MakeVDLTarget() vdl.Target {
+ return &BlobRefTarget{Value: m}
+}
+
+type BlobRefTarget struct {
+ Value *BlobRef
+ vdl.TargetBase
+}
+
+func (t *BlobRefTarget) FromString(src string, tt *vdl.Type) error {
+
+ if ttWant := vdl.TypeOf((*BlobRef)(nil)); !vdl.Compatible(tt, ttWant) {
+ return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ *t.Value = BlobRef(src)
+
+ return nil
+}
+func (t *BlobRefTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BlobRef("")
+ return nil
+}
+
+// BlobFetchState represents the state transitions of a blob fetch.
+type BlobFetchState int
+
+const (
+ BlobFetchStatePending BlobFetchState = iota
+ BlobFetchStateLocating
+ BlobFetchStateFetching
+ BlobFetchStateDone
+)
+
+// BlobFetchStateAll holds all labels for BlobFetchState.
+var BlobFetchStateAll = [...]BlobFetchState{BlobFetchStatePending, BlobFetchStateLocating, BlobFetchStateFetching, BlobFetchStateDone}
+
+// BlobFetchStateFromString creates a BlobFetchState from a string label.
+func BlobFetchStateFromString(label string) (x BlobFetchState, err error) {
+ err = x.Set(label)
+ return
+}
+
+// Set assigns label to x.
+func (x *BlobFetchState) Set(label string) error {
+ switch label {
+ case "Pending", "pending":
+ *x = BlobFetchStatePending
+ return nil
+ case "Locating", "locating":
+ *x = BlobFetchStateLocating
+ return nil
+ case "Fetching", "fetching":
+ *x = BlobFetchStateFetching
+ return nil
+ case "Done", "done":
+ *x = BlobFetchStateDone
+ return nil
+ }
+ *x = -1
+ return fmt.Errorf("unknown label %q in nosql.BlobFetchState", label)
+}
+
+// String returns the string label of x.
+func (x BlobFetchState) String() string {
+ switch x {
+ case BlobFetchStatePending:
+ return "Pending"
+ case BlobFetchStateLocating:
+ return "Locating"
+ case BlobFetchStateFetching:
+ return "Fetching"
+ case BlobFetchStateDone:
+ return "Done"
+ }
+ return ""
+}
+
+func (BlobFetchState) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.BlobFetchState"`
+ Enum struct{ Pending, Locating, Fetching, Done string }
+}) {
+}
+
+func (m *BlobFetchState) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ if err := t.FromEnumLabel((*m).String(), tt); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (m *BlobFetchState) MakeVDLTarget() vdl.Target {
+ return &BlobFetchStateTarget{Value: m}
+}
+
+type BlobFetchStateTarget struct {
+ Value *BlobFetchState
+ vdl.TargetBase
+}
+
+func (t *BlobFetchStateTarget) FromEnumLabel(src string, tt *vdl.Type) error {
+
+ if ttWant := vdl.TypeOf((*BlobFetchState)(nil)); !vdl.Compatible(tt, ttWant) {
+ return fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ switch src {
+ case "Pending":
+ *t.Value = 0
+ case "Locating":
+ *t.Value = 1
+ case "Fetching":
+ *t.Value = 2
+ case "Done":
+ *t.Value = 3
+ default:
+ return fmt.Errorf("label %s not in enum BlobFetchStatePending", src)
+ }
+
+ return nil
+}
+func (t *BlobFetchStateTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BlobFetchStatePending
+ return nil
+}
+
+// BlobFetchStatus describes the progress of an asynchronous blob fetch.
+type BlobFetchStatus struct {
+ State BlobFetchState // State of the blob fetch request.
+ Received int64 // Total number of bytes received.
+ Total int64 // Blob size.
+}
+
+func (BlobFetchStatus) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.BlobFetchStatus"`
+}) {
+}
+
+func (m *BlobFetchStatus) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
+ fieldsTarget1, err := t.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("State")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var4 := (m.State == BlobFetchStatePending)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Received")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var7 := (m.Received == int64(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromInt(int64(m.Received), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ return err
+ }
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Total")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var10 := (m.Total == int64(0))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromInt(int64(m.Total), 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 *BlobFetchStatus) MakeVDLTarget() vdl.Target {
+ return &BlobFetchStatusTarget{Value: m}
+}
+
+type BlobFetchStatusTarget struct {
+ Value *BlobFetchStatus
+ stateTarget BlobFetchStateTarget
+ receivedTarget vdl.Int64Target
+ totalTarget vdl.Int64Target
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *BlobFetchStatusTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*BlobFetchStatus)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *BlobFetchStatusTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "State":
+ t.stateTarget.Value = &t.Value.State
+ target, err := &t.stateTarget, error(nil)
+ return nil, target, err
+ case "Received":
+ t.receivedTarget.Value = &t.Value.Received
+ target, err := &t.receivedTarget, error(nil)
+ return nil, target, err
+ case "Total":
+ t.totalTarget.Value = &t.Value.Total
+ target, err := &t.totalTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.BlobFetchStatus", name)
+ }
+}
+func (t *BlobFetchStatusTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *BlobFetchStatusTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *BlobFetchStatusTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BlobFetchStatus{}
+ return nil
+}
+
+// StoreChange is the new value for a watched entity.
+// TODO(rogulenko): Consider adding the Shell state.
+type StoreChange struct {
+ // Value is the new value for the row if the Change state equals to Exists,
+ // otherwise the Value is nil.
+ Value []byte
+ // FromSync indicates whether the change came from sync. If FromSync is
+ // false, then the change originated from the local device.
+ // Note: FromSync is always false for initial state Changes.
+ FromSync bool
+}
+
+func (StoreChange) __VDLReflect(struct {
+ Name string `vdl:"v.io/v23/services/syncbase/nosql.StoreChange"`
+}) {
+}
+
+func (m *StoreChange) 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 != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var4 bool
+ if len(m.Value) == 0 {
+ var4 = true
+ }
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget3.FromBytes([]byte(m.Value), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
+ return err
+ }
+ }
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("FromSync")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var7 := (m.FromSync == false)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromBool(bool(m.FromSync), 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 *StoreChange) MakeVDLTarget() vdl.Target {
+ return &StoreChangeTarget{Value: m}
+}
+
+type StoreChangeTarget struct {
+ Value *StoreChange
+ valueTarget vdl.BytesTarget
+ fromSyncTarget vdl.BoolTarget
+ vdl.TargetBase
+ vdl.FieldsTargetBase
+}
+
+func (t *StoreChangeTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
+
+ if ttWant := vdl.TypeOf((*StoreChange)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
+ return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
+ }
+ return t, nil
+}
+func (t *StoreChangeTarget) StartField(name string) (key, field vdl.Target, _ error) {
+ switch name {
+ case "Value":
+ t.valueTarget.Value = &t.Value.Value
+ target, err := &t.valueTarget, error(nil)
+ return nil, target, err
+ case "FromSync":
+ t.fromSyncTarget.Value = &t.Value.FromSync
+ target, err := &t.fromSyncTarget, error(nil)
+ return nil, target, err
+ default:
+ return nil, nil, fmt.Errorf("field %s not in struct v.io/v23/services/syncbase/nosql.StoreChange", name)
+ }
+}
+func (t *StoreChangeTarget) FinishField(_, _ vdl.Target) error {
+ return nil
+}
+func (t *StoreChangeTarget) FinishFields(_ vdl.FieldsTarget) error {
+
+ return nil
+}
+func (t *StoreChangeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = StoreChange{}
+ return nil
+}
+
+//////////////////////////////////////////////////
+// Const definitions
+
+const NullBlobRef = BlobRef("")
+
+//////////////////////////////////////////////////
+// Error definitions
+var (
+ ErrBoundToBatch = verror.Register("v.io/v23/services/syncbase/nosql.BoundToBatch", verror.NoRetry, "{1:}{2:} bound to batch")
+ ErrNotBoundToBatch = verror.Register("v.io/v23/services/syncbase/nosql.NotBoundToBatch", verror.NoRetry, "{1:}{2:} not bound to batch")
+ ErrReadOnlyBatch = verror.Register("v.io/v23/services/syncbase/nosql.ReadOnlyBatch", verror.NoRetry, "{1:}{2:} batch is read-only")
+ ErrConcurrentBatch = verror.Register("v.io/v23/services/syncbase/nosql.ConcurrentBatch", verror.NoRetry, "{1:}{2:} concurrent batch")
+ ErrSchemaVersionMismatch = verror.Register("v.io/v23/services/syncbase/nosql.SchemaVersionMismatch", verror.NoRetry, "{1:}{2:} actual schema version does not match the provided one")
+ ErrBlobNotCommitted = verror.Register("v.io/v23/services/syncbase/nosql.BlobNotCommitted", verror.NoRetry, "{1:}{2:} blob is not yet committed")
+ ErrSyncgroupJoinFailed = verror.Register("v.io/v23/services/syncbase/nosql.SyncgroupJoinFailed", verror.NoRetry, "{1:}{2:} syncgroup join failed")
+)
+
+// NewErrBoundToBatch returns an error with the ErrBoundToBatch ID.
+func NewErrBoundToBatch(ctx *context.T) error {
+ return verror.New(ErrBoundToBatch, ctx)
+}
+
+// NewErrNotBoundToBatch returns an error with the ErrNotBoundToBatch ID.
+func NewErrNotBoundToBatch(ctx *context.T) error {
+ return verror.New(ErrNotBoundToBatch, ctx)
+}
+
+// NewErrReadOnlyBatch returns an error with the ErrReadOnlyBatch ID.
+func NewErrReadOnlyBatch(ctx *context.T) error {
+ return verror.New(ErrReadOnlyBatch, ctx)
+}
+
+// NewErrConcurrentBatch returns an error with the ErrConcurrentBatch ID.
+func NewErrConcurrentBatch(ctx *context.T) error {
+ return verror.New(ErrConcurrentBatch, ctx)
+}
+
+// NewErrSchemaVersionMismatch returns an error with the ErrSchemaVersionMismatch ID.
+func NewErrSchemaVersionMismatch(ctx *context.T) error {
+ return verror.New(ErrSchemaVersionMismatch, ctx)
+}
+
+// NewErrBlobNotCommitted returns an error with the ErrBlobNotCommitted ID.
+func NewErrBlobNotCommitted(ctx *context.T) error {
+ return verror.New(ErrBlobNotCommitted, ctx)
+}
+
+// NewErrSyncgroupJoinFailed returns an error with the ErrSyncgroupJoinFailed ID.
+func NewErrSyncgroupJoinFailed(ctx *context.T) error {
+ return verror.New(ErrSyncgroupJoinFailed, ctx)
+}
+
+//////////////////////////////////////////////////
+// Interface definitions
+
+// DatabaseWatcherClientMethods is the client interface
+// containing DatabaseWatcher methods.
+//
+// DatabaseWatcher allows a client to watch for updates to the database. For
+// each watch request, the client will receive a reliable stream of watch events
+// without re-ordering. See watch.GlobWatcher for a detailed explanation of the
+// behavior.
+// TODO(rogulenko): Currently the only supported watch patterns are
+// "<tableName>/<rowPrefix>*". Consider changing that.
+//
+// Watching is done by starting a streaming RPC. The RPC takes a ResumeMarker
+// argument that points to a particular place in the database event log. If an
+// empty ResumeMarker is provided, the WatchStream will begin with a Change
+// batch containing the initial state. Otherwise, the WatchStream will contain
+// only changes since the provided ResumeMarker.
+//
+// The result stream consists of a never-ending sequence of Change messages
+// (until the call fails or is canceled). Each Change contains the Name field
+// in the form "<tableName>/<rowKey>" and the Value field of the StoreChange
+// type. If the client has no access to a row specified in a change, that change
+// is excluded from the result stream.
+//
+// Note: A single Watch Change batch may contain changes from more than one
+// batch as originally committed on a remote Syncbase or obtained from conflict
+// resolution. However, changes from a single original batch will always appear
+// in the same Change batch.
+type DatabaseWatcherClientMethods interface {
+ // GlobWatcher allows a client to receive updates for changes to objects
+ // that match a pattern. See the package comments for details.
+ watch.GlobWatcherClientMethods
+ // GetResumeMarker returns the ResumeMarker that points to the current end
+ // of the event log. GetResumeMarker() can be called on a batch.
+ GetResumeMarker(*context.T, ...rpc.CallOpt) (watch.ResumeMarker, error)
+}
+
+// DatabaseWatcherClientStub adds universal methods to DatabaseWatcherClientMethods.
+type DatabaseWatcherClientStub interface {
+ DatabaseWatcherClientMethods
+ rpc.UniversalServiceMethods
+}
+
+// DatabaseWatcherClient returns a client stub for DatabaseWatcher.
+func DatabaseWatcherClient(name string) DatabaseWatcherClientStub {
+ return implDatabaseWatcherClientStub{name, watch.GlobWatcherClient(name)}
+}
+
+type implDatabaseWatcherClientStub struct {
+ name string
+
+ watch.GlobWatcherClientStub
+}
+
+func (c implDatabaseWatcherClientStub) GetResumeMarker(ctx *context.T, opts ...rpc.CallOpt) (o0 watch.ResumeMarker, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "GetResumeMarker", nil, []interface{}{&o0}, opts...)
+ return
+}
+
+// DatabaseWatcherServerMethods is the interface a server writer
+// implements for DatabaseWatcher.
+//
+// DatabaseWatcher allows a client to watch for updates to the database. For
+// each watch request, the client will receive a reliable stream of watch events
+// without re-ordering. See watch.GlobWatcher for a detailed explanation of the
+// behavior.
+// TODO(rogulenko): Currently the only supported watch patterns are
+// "<tableName>/<rowPrefix>*". Consider changing that.
+//
+// Watching is done by starting a streaming RPC. The RPC takes a ResumeMarker
+// argument that points to a particular place in the database event log. If an
+// empty ResumeMarker is provided, the WatchStream will begin with a Change
+// batch containing the initial state. Otherwise, the WatchStream will contain
+// only changes since the provided ResumeMarker.
+//
+// The result stream consists of a never-ending sequence of Change messages
+// (until the call fails or is canceled). Each Change contains the Name field
+// in the form "<tableName>/<rowKey>" and the Value field of the StoreChange
+// type. If the client has no access to a row specified in a change, that change
+// is excluded from the result stream.
+//
+// Note: A single Watch Change batch may contain changes from more than one
+// batch as originally committed on a remote Syncbase or obtained from conflict
+// resolution. However, changes from a single original batch will always appear
+// in the same Change batch.
+type DatabaseWatcherServerMethods interface {
+ // GlobWatcher allows a client to receive updates for changes to objects
+ // that match a pattern. See the package comments for details.
+ watch.GlobWatcherServerMethods
+ // GetResumeMarker returns the ResumeMarker that points to the current end
+ // of the event log. GetResumeMarker() can be called on a batch.
+ GetResumeMarker(*context.T, rpc.ServerCall) (watch.ResumeMarker, error)
+}
+
+// DatabaseWatcherServerStubMethods is the server interface containing
+// DatabaseWatcher methods, as expected by rpc.Server.
+// The only difference between this interface and DatabaseWatcherServerMethods
+// is the streaming methods.
+type DatabaseWatcherServerStubMethods interface {
+ // GlobWatcher allows a client to receive updates for changes to objects
+ // that match a pattern. See the package comments for details.
+ watch.GlobWatcherServerStubMethods
+ // GetResumeMarker returns the ResumeMarker that points to the current end
+ // of the event log. GetResumeMarker() can be called on a batch.
+ GetResumeMarker(*context.T, rpc.ServerCall) (watch.ResumeMarker, error)
+}
+
+// DatabaseWatcherServerStub adds universal methods to DatabaseWatcherServerStubMethods.
+type DatabaseWatcherServerStub interface {
+ DatabaseWatcherServerStubMethods
+ // Describe the DatabaseWatcher interfaces.
+ Describe__() []rpc.InterfaceDesc
+}
+
+// DatabaseWatcherServer returns a server stub for DatabaseWatcher.
+// It converts an implementation of DatabaseWatcherServerMethods into
+// an object that may be used by rpc.Server.
+func DatabaseWatcherServer(impl DatabaseWatcherServerMethods) DatabaseWatcherServerStub {
+ stub := implDatabaseWatcherServerStub{
+ impl: impl,
+ GlobWatcherServerStub: watch.GlobWatcherServer(impl),
+ }
+ // Initialize GlobState; always check the stub itself first, to handle the
+ // case where the user has the Glob method defined in their VDL source.
+ if gs := rpc.NewGlobState(stub); gs != nil {
+ stub.gs = gs
+ } else if gs := rpc.NewGlobState(impl); gs != nil {
+ stub.gs = gs
+ }
+ return stub
+}
+
+type implDatabaseWatcherServerStub struct {
+ impl DatabaseWatcherServerMethods
+ watch.GlobWatcherServerStub
+ gs *rpc.GlobState
+}
+
+func (s implDatabaseWatcherServerStub) GetResumeMarker(ctx *context.T, call rpc.ServerCall) (watch.ResumeMarker, error) {
+ return s.impl.GetResumeMarker(ctx, call)
+}
+
+func (s implDatabaseWatcherServerStub) Globber() *rpc.GlobState {
+ return s.gs
+}
+
+func (s implDatabaseWatcherServerStub) Describe__() []rpc.InterfaceDesc {
+ return []rpc.InterfaceDesc{DatabaseWatcherDesc, watch.GlobWatcherDesc}
+}
+
+// DatabaseWatcherDesc describes the DatabaseWatcher interface.
+var DatabaseWatcherDesc rpc.InterfaceDesc = descDatabaseWatcher
+
+// descDatabaseWatcher hides the desc to keep godoc clean.
+var descDatabaseWatcher = rpc.InterfaceDesc{
+ Name: "DatabaseWatcher",
+ PkgPath: "v.io/v23/services/syncbase/nosql",
+ Doc: "// DatabaseWatcher allows a client to watch for updates to the database. For\n// each watch request, the client will receive a reliable stream of watch events\n// without re-ordering. See watch.GlobWatcher for a detailed explanation of the\n// behavior.\n// TODO(rogulenko): Currently the only supported watch patterns are\n// \"<tableName>/<rowPrefix>*\". Consider changing that.\n//\n// Watching is done by starting a streaming RPC. The RPC takes a ResumeMarker\n// argument that points to a particular place in the database event log. If an\n// empty ResumeMarker is provided, the WatchStream will begin with a Change\n// batch containing the initial state. Otherwise, the WatchStream will contain\n// only changes since the provided ResumeMarker.\n//\n// The result stream consists of a never-ending sequence of Change messages\n// (until the call fails or is canceled). Each Change contains the Name field\n// in the form \"<tableName>/<rowKey>\" and the Value field of the StoreChange\n// type. If the client has no access to a row specified in a change, that change\n// is excluded from the result stream.\n//\n// Note: A single Watch Change batch may contain changes from more than one\n// batch as originally committed on a remote Syncbase or obtained from conflict\n// resolution. However, changes from a single original batch will always appear\n// in the same Change batch.",
+ Embeds: []rpc.EmbedDesc{
+ {"GlobWatcher", "v.io/v23/services/watch", "// GlobWatcher allows a client to receive updates for changes to objects\n// that match a pattern. See the package comments for details."},
+ },
+ Methods: []rpc.MethodDesc{
+ {
+ Name: "GetResumeMarker",
+ Doc: "// GetResumeMarker returns the ResumeMarker that points to the current end\n// of the event log. GetResumeMarker() can be called on a batch.",
+ OutArgs: []rpc.ArgDesc{
+ {"", ``}, // watch.ResumeMarker
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ },
+}
+
+// SyncgroupManagerClientMethods is the client interface
+// containing SyncgroupManager methods.
+//
+// SyncgroupManager is the interface for syncgroup operations.
+// TODO(hpucha): Add blessings to create/join and add a refresh method.
+type SyncgroupManagerClientMethods interface {
+ // GetSyncgroupNames returns the global names of all syncgroups attached to
+ // this database.
+ GetSyncgroupNames(*context.T, ...rpc.CallOpt) ([]string, error)
+ // CreateSyncgroup creates a new syncgroup with the given spec.
+ //
+ // Requires: Client must have at least Read access on the Database; prefix ACL
+ // must exist at each syncgroup prefix; Client must have at least Read access
+ // on each of these prefix ACLs.
+ CreateSyncgroup(_ *context.T, sgName string, spec SyncgroupSpec, myInfo SyncgroupMemberInfo, _ ...rpc.CallOpt) error
+ // JoinSyncgroup joins the syncgroup.
+ //
+ // Requires: Client must have at least Read access on the Database and on the
+ // syncgroup ACL.
+ JoinSyncgroup(_ *context.T, sgName string, myInfo SyncgroupMemberInfo, _ ...rpc.CallOpt) (spec SyncgroupSpec, _ error)
+ // LeaveSyncgroup leaves the syncgroup. Previously synced data will continue
+ // to be available.
+ //
+ // Requires: Client must have at least Read access on the Database.
+ LeaveSyncgroup(_ *context.T, sgName string, _ ...rpc.CallOpt) error
+ // DestroySyncgroup destroys the syncgroup. Previously synced data will
+ // continue to be available to all members.
+ //
+ // Requires: Client must have at least Read access on the Database, and must
+ // have Admin access on the syncgroup ACL.
+ DestroySyncgroup(_ *context.T, sgName string, _ ...rpc.CallOpt) error
+ // EjectFromSyncgroup ejects a member from the syncgroup. The ejected member
+ // will not be able to sync further, but will retain any data it has already
+ // synced.
+ //
+ // Requires: Client must have at least Read access on the Database, and must
+ // have Admin access on the syncgroup ACL.
+ EjectFromSyncgroup(_ *context.T, sgName string, member string, _ ...rpc.CallOpt) error
+ // GetSyncgroupSpec gets the syncgroup spec. version allows for atomic
+ // read-modify-write of the spec - see comment for SetSyncgroupSpec.
+ //
+ // Requires: Client must have at least Read access on the Database and on the
+ // syncgroup ACL.
+ GetSyncgroupSpec(_ *context.T, sgName string, _ ...rpc.CallOpt) (spec SyncgroupSpec, version string, _ error)
+ // SetSyncgroupSpec sets the syncgroup spec. version may be either empty or
+ // the value from a previous Get. If not empty, Set will only succeed if the
+ // current version matches the specified one.
+ //
+ // Requires: Client must have at least Read access on the Database, and must
+ // have Admin access on the syncgroup ACL.
+ SetSyncgroupSpec(_ *context.T, sgName string, spec SyncgroupSpec, version string, _ ...rpc.CallOpt) error
+ // GetSyncgroupMembers gets the info objects for members of the syncgroup.
+ //
+ // Requires: Client must have at least Read access on the Database and on the
+ // syncgroup ACL.
+ GetSyncgroupMembers(_ *context.T, sgName string, _ ...rpc.CallOpt) (members map[string]SyncgroupMemberInfo, _ error)
+}
+
+// SyncgroupManagerClientStub adds universal methods to SyncgroupManagerClientMethods.
+type SyncgroupManagerClientStub interface {
+ SyncgroupManagerClientMethods
+ rpc.UniversalServiceMethods
+}
+
+// SyncgroupManagerClient returns a client stub for SyncgroupManager.
+func SyncgroupManagerClient(name string) SyncgroupManagerClientStub {
+ return implSyncgroupManagerClientStub{name}
+}
+
+type implSyncgroupManagerClientStub struct {
+ name string
+}
+
+func (c implSyncgroupManagerClientStub) GetSyncgroupNames(ctx *context.T, opts ...rpc.CallOpt) (o0 []string, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "GetSyncgroupNames", nil, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implSyncgroupManagerClientStub) CreateSyncgroup(ctx *context.T, i0 string, i1 SyncgroupSpec, i2 SyncgroupMemberInfo, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "CreateSyncgroup", []interface{}{i0, i1, i2}, nil, opts...)
+ return
+}
+
+func (c implSyncgroupManagerClientStub) JoinSyncgroup(ctx *context.T, i0 string, i1 SyncgroupMemberInfo, opts ...rpc.CallOpt) (o0 SyncgroupSpec, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "JoinSyncgroup", []interface{}{i0, i1}, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implSyncgroupManagerClientStub) LeaveSyncgroup(ctx *context.T, i0 string, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "LeaveSyncgroup", []interface{}{i0}, nil, opts...)
+ return
+}
+
+func (c implSyncgroupManagerClientStub) DestroySyncgroup(ctx *context.T, i0 string, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "DestroySyncgroup", []interface{}{i0}, nil, opts...)
+ return
+}
+
+func (c implSyncgroupManagerClientStub) EjectFromSyncgroup(ctx *context.T, i0 string, i1 string, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "EjectFromSyncgroup", []interface{}{i0, i1}, nil, opts...)
+ return
+}
+
+func (c implSyncgroupManagerClientStub) GetSyncgroupSpec(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 SyncgroupSpec, o1 string, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "GetSyncgroupSpec", []interface{}{i0}, []interface{}{&o0, &o1}, opts...)
+ return
+}
+
+func (c implSyncgroupManagerClientStub) SetSyncgroupSpec(ctx *context.T, i0 string, i1 SyncgroupSpec, i2 string, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "SetSyncgroupSpec", []interface{}{i0, i1, i2}, nil, opts...)
+ return
+}
+
+func (c implSyncgroupManagerClientStub) GetSyncgroupMembers(ctx *context.T, i0 string, opts ...rpc.CallOpt) (o0 map[string]SyncgroupMemberInfo, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "GetSyncgroupMembers", []interface{}{i0}, []interface{}{&o0}, opts...)
+ return
+}
+
+// SyncgroupManagerServerMethods is the interface a server writer
+// implements for SyncgroupManager.
+//
+// SyncgroupManager is the interface for syncgroup operations.
+// TODO(hpucha): Add blessings to create/join and add a refresh method.
+type SyncgroupManagerServerMethods interface {
+ // GetSyncgroupNames returns the global names of all syncgroups attached to
+ // this database.
+ GetSyncgroupNames(*context.T, rpc.ServerCall) ([]string, error)
+ // CreateSyncgroup creates a new syncgroup with the given spec.
+ //
+ // Requires: Client must have at least Read access on the Database; prefix ACL
+ // must exist at each syncgroup prefix; Client must have at least Read access
+ // on each of these prefix ACLs.
+ CreateSyncgroup(_ *context.T, _ rpc.ServerCall, sgName string, spec SyncgroupSpec, myInfo SyncgroupMemberInfo) error
+ // JoinSyncgroup joins the syncgroup.
+ //
+ // Requires: Client must have at least Read access on the Database and on the
+ // syncgroup ACL.
+ JoinSyncgroup(_ *context.T, _ rpc.ServerCall, sgName string, myInfo SyncgroupMemberInfo) (spec SyncgroupSpec, _ error)
+ // LeaveSyncgroup leaves the syncgroup. Previously synced data will continue
+ // to be available.
+ //
+ // Requires: Client must have at least Read access on the Database.
+ LeaveSyncgroup(_ *context.T, _ rpc.ServerCall, sgName string) error
+ // DestroySyncgroup destroys the syncgroup. Previously synced data will
+ // continue to be available to all members.
+ //
+ // Requires: Client must have at least Read access on the Database, and must
+ // have Admin access on the syncgroup ACL.
+ DestroySyncgroup(_ *context.T, _ rpc.ServerCall, sgName string) error
+ // EjectFromSyncgroup ejects a member from the syncgroup. The ejected member
+ // will not be able to sync further, but will retain any data it has already
+ // synced.
+ //
+ // Requires: Client must have at least Read access on the Database, and must
+ // have Admin access on the syncgroup ACL.
+ EjectFromSyncgroup(_ *context.T, _ rpc.ServerCall, sgName string, member string) error
+ // GetSyncgroupSpec gets the syncgroup spec. version allows for atomic
+ // read-modify-write of the spec - see comment for SetSyncgroupSpec.
+ //
+ // Requires: Client must have at least Read access on the Database and on the
+ // syncgroup ACL.
+ GetSyncgroupSpec(_ *context.T, _ rpc.ServerCall, sgName string) (spec SyncgroupSpec, version string, _ error)
+ // SetSyncgroupSpec sets the syncgroup spec. version may be either empty or
+ // the value from a previous Get. If not empty, Set will only succeed if the
+ // current version matches the specified one.
+ //
+ // Requires: Client must have at least Read access on the Database, and must
+ // have Admin access on the syncgroup ACL.
+ SetSyncgroupSpec(_ *context.T, _ rpc.ServerCall, sgName string, spec SyncgroupSpec, version string) error
+ // GetSyncgroupMembers gets the info objects for members of the syncgroup.
+ //
+ // Requires: Client must have at least Read access on the Database and on the
+ // syncgroup ACL.
+ GetSyncgroupMembers(_ *context.T, _ rpc.ServerCall, sgName string) (members map[string]SyncgroupMemberInfo, _ error)
+}
+
+// SyncgroupManagerServerStubMethods is the server interface containing
+// SyncgroupManager methods, as expected by rpc.Server.
+// There is no difference between this interface and SyncgroupManagerServerMethods
+// since there are no streaming methods.
+type SyncgroupManagerServerStubMethods SyncgroupManagerServerMethods
+
+// SyncgroupManagerServerStub adds universal methods to SyncgroupManagerServerStubMethods.
+type SyncgroupManagerServerStub interface {
+ SyncgroupManagerServerStubMethods
+ // Describe the SyncgroupManager interfaces.
+ Describe__() []rpc.InterfaceDesc
+}
+
+// SyncgroupManagerServer returns a server stub for SyncgroupManager.
+// It converts an implementation of SyncgroupManagerServerMethods into
+// an object that may be used by rpc.Server.
+func SyncgroupManagerServer(impl SyncgroupManagerServerMethods) SyncgroupManagerServerStub {
+ stub := implSyncgroupManagerServerStub{
+ impl: impl,
+ }
+ // Initialize GlobState; always check the stub itself first, to handle the
+ // case where the user has the Glob method defined in their VDL source.
+ if gs := rpc.NewGlobState(stub); gs != nil {
+ stub.gs = gs
+ } else if gs := rpc.NewGlobState(impl); gs != nil {
+ stub.gs = gs
+ }
+ return stub
+}
+
+type implSyncgroupManagerServerStub struct {
+ impl SyncgroupManagerServerMethods
+ gs *rpc.GlobState
+}
+
+func (s implSyncgroupManagerServerStub) GetSyncgroupNames(ctx *context.T, call rpc.ServerCall) ([]string, error) {
+ return s.impl.GetSyncgroupNames(ctx, call)
+}
+
+func (s implSyncgroupManagerServerStub) CreateSyncgroup(ctx *context.T, call rpc.ServerCall, i0 string, i1 SyncgroupSpec, i2 SyncgroupMemberInfo) error {
+ return s.impl.CreateSyncgroup(ctx, call, i0, i1, i2)
+}
+
+func (s implSyncgroupManagerServerStub) JoinSyncgroup(ctx *context.T, call rpc.ServerCall, i0 string, i1 SyncgroupMemberInfo) (SyncgroupSpec, error) {
+ return s.impl.JoinSyncgroup(ctx, call, i0, i1)
+}
+
+func (s implSyncgroupManagerServerStub) LeaveSyncgroup(ctx *context.T, call rpc.ServerCall, i0 string) error {
+ return s.impl.LeaveSyncgroup(ctx, call, i0)
+}
+
+func (s implSyncgroupManagerServerStub) DestroySyncgroup(ctx *context.T, call rpc.ServerCall, i0 string) error {
+ return s.impl.DestroySyncgroup(ctx, call, i0)
+}
+
+func (s implSyncgroupManagerServerStub) EjectFromSyncgroup(ctx *context.T, call rpc.ServerCall, i0 string, i1 string) error {
+ return s.impl.EjectFromSyncgroup(ctx, call, i0, i1)
+}
+
+func (s implSyncgroupManagerServerStub) GetSyncgroupSpec(ctx *context.T, call rpc.ServerCall, i0 string) (SyncgroupSpec, string, error) {
+ return s.impl.GetSyncgroupSpec(ctx, call, i0)
+}
+
+func (s implSyncgroupManagerServerStub) SetSyncgroupSpec(ctx *context.T, call rpc.ServerCall, i0 string, i1 SyncgroupSpec, i2 string) error {
+ return s.impl.SetSyncgroupSpec(ctx, call, i0, i1, i2)
+}
+
+func (s implSyncgroupManagerServerStub) GetSyncgroupMembers(ctx *context.T, call rpc.ServerCall, i0 string) (map[string]SyncgroupMemberInfo, error) {
+ return s.impl.GetSyncgroupMembers(ctx, call, i0)
+}
+
+func (s implSyncgroupManagerServerStub) Globber() *rpc.GlobState {
+ return s.gs
+}
+
+func (s implSyncgroupManagerServerStub) Describe__() []rpc.InterfaceDesc {
+ return []rpc.InterfaceDesc{SyncgroupManagerDesc}
+}
+
+// SyncgroupManagerDesc describes the SyncgroupManager interface.
+var SyncgroupManagerDesc rpc.InterfaceDesc = descSyncgroupManager
+
+// descSyncgroupManager hides the desc to keep godoc clean.
+var descSyncgroupManager = rpc.InterfaceDesc{
+ Name: "SyncgroupManager",
+ PkgPath: "v.io/v23/services/syncbase/nosql",
+ Doc: "// SyncgroupManager is the interface for syncgroup operations.\n// TODO(hpucha): Add blessings to create/join and add a refresh method.",
+ Methods: []rpc.MethodDesc{
+ {
+ Name: "GetSyncgroupNames",
+ Doc: "// GetSyncgroupNames returns the global names of all syncgroups attached to\n// this database.",
+ OutArgs: []rpc.ArgDesc{
+ {"", ``}, // []string
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "CreateSyncgroup",
+ Doc: "// CreateSyncgroup creates a new syncgroup with the given spec.\n//\n// Requires: Client must have at least Read access on the Database; prefix ACL\n// must exist at each syncgroup prefix; Client must have at least Read access\n// on each of these prefix ACLs.",
+ InArgs: []rpc.ArgDesc{
+ {"sgName", ``}, // string
+ {"spec", ``}, // SyncgroupSpec
+ {"myInfo", ``}, // SyncgroupMemberInfo
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "JoinSyncgroup",
+ Doc: "// JoinSyncgroup joins the syncgroup.\n//\n// Requires: Client must have at least Read access on the Database and on the\n// syncgroup ACL.",
+ InArgs: []rpc.ArgDesc{
+ {"sgName", ``}, // string
+ {"myInfo", ``}, // SyncgroupMemberInfo
+ },
+ OutArgs: []rpc.ArgDesc{
+ {"spec", ``}, // SyncgroupSpec
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "LeaveSyncgroup",
+ Doc: "// LeaveSyncgroup leaves the syncgroup. Previously synced data will continue\n// to be available.\n//\n// Requires: Client must have at least Read access on the Database.",
+ InArgs: []rpc.ArgDesc{
+ {"sgName", ``}, // string
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "DestroySyncgroup",
+ Doc: "// DestroySyncgroup destroys the syncgroup. Previously synced data will\n// continue to be available to all members.\n//\n// Requires: Client must have at least Read access on the Database, and must\n// have Admin access on the syncgroup ACL.",
+ InArgs: []rpc.ArgDesc{
+ {"sgName", ``}, // string
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "EjectFromSyncgroup",
+ Doc: "// EjectFromSyncgroup ejects a member from the syncgroup. The ejected member\n// will not be able to sync further, but will retain any data it has already\n// synced.\n//\n// Requires: Client must have at least Read access on the Database, and must\n// have Admin access on the syncgroup ACL.",
+ InArgs: []rpc.ArgDesc{
+ {"sgName", ``}, // string
+ {"member", ``}, // string
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "GetSyncgroupSpec",
+ Doc: "// GetSyncgroupSpec gets the syncgroup spec. version allows for atomic\n// read-modify-write of the spec - see comment for SetSyncgroupSpec.\n//\n// Requires: Client must have at least Read access on the Database and on the\n// syncgroup ACL.",
+ InArgs: []rpc.ArgDesc{
+ {"sgName", ``}, // string
+ },
+ OutArgs: []rpc.ArgDesc{
+ {"spec", ``}, // SyncgroupSpec
+ {"version", ``}, // string
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "SetSyncgroupSpec",
+ Doc: "// SetSyncgroupSpec sets the syncgroup spec. version may be either empty or\n// the value from a previous Get. If not empty, Set will only succeed if the\n// current version matches the specified one.\n//\n// Requires: Client must have at least Read access on the Database, and must\n// have Admin access on the syncgroup ACL.",
+ InArgs: []rpc.ArgDesc{
+ {"sgName", ``}, // string
+ {"spec", ``}, // SyncgroupSpec
+ {"version", ``}, // string
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "GetSyncgroupMembers",
+ Doc: "// GetSyncgroupMembers gets the info objects for members of the syncgroup.\n//\n// Requires: Client must have at least Read access on the Database and on the\n// syncgroup ACL.",
+ InArgs: []rpc.ArgDesc{
+ {"sgName", ``}, // string
+ },
+ OutArgs: []rpc.ArgDesc{
+ {"members", ``}, // map[string]SyncgroupMemberInfo
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ },
+}
+
+// BlobManagerClientMethods is the client interface
+// containing BlobManager methods.
+//
+// BlobManager is the interface for blob operations.
+//
+// Description of API for resumable blob creation (append-only):
+// - Up until commit, a BlobRef may be used with PutBlob, GetBlobSize,
+// DeleteBlob, and CommitBlob. Blob creation may be resumed by obtaining the
+// current blob size via GetBlobSize and appending to the blob via PutBlob.
+// - After commit, a blob is immutable, at which point PutBlob and CommitBlob
+// may no longer be used.
+// - All other methods (GetBlob, FetchBlob, PinBlob, etc.) may only be used
+// after commit.
+type BlobManagerClientMethods interface {
+ // CreateBlob returns a BlobRef for a newly created blob.
+ CreateBlob(*context.T, ...rpc.CallOpt) (br BlobRef, _ error)
+ // PutBlob appends the byte stream to the blob.
+ PutBlob(_ *context.T, br BlobRef, _ ...rpc.CallOpt) (BlobManagerPutBlobClientCall, error)
+ // CommitBlob marks the blob as immutable.
+ CommitBlob(_ *context.T, br BlobRef, _ ...rpc.CallOpt) error
+ // GetBlobSize returns the count of bytes written as part of the blob
+ // (committed or uncommitted).
+ GetBlobSize(_ *context.T, br BlobRef, _ ...rpc.CallOpt) (int64, error)
+ // DeleteBlob locally deletes the blob (committed or uncommitted).
+ DeleteBlob(_ *context.T, br BlobRef, _ ...rpc.CallOpt) error
+ // GetBlob returns the byte stream from a committed blob starting at offset.
+ GetBlob(_ *context.T, br BlobRef, offset int64, _ ...rpc.CallOpt) (BlobManagerGetBlobClientCall, error)
+ // FetchBlob initiates fetching a blob if not locally found. priority
+ // controls the network priority of the blob. Higher priority blobs are
+ // fetched before the lower priority ones. However, an ongoing blob
+ // transfer is not interrupted. Status updates are streamed back to the
+ // client as fetch is in progress.
+ FetchBlob(_ *context.T, br BlobRef, priority uint64, _ ...rpc.CallOpt) (BlobManagerFetchBlobClientCall, error)
+ // PinBlob locally pins the blob so that it is not evicted.
+ PinBlob(_ *context.T, br BlobRef, _ ...rpc.CallOpt) error
+ // UnpinBlob locally unpins the blob so that it can be evicted if needed.
+ UnpinBlob(_ *context.T, br BlobRef, _ ...rpc.CallOpt) error
+ // KeepBlob locally caches the blob with the specified rank. Lower
+ // ranked blobs are more eagerly evicted.
+ KeepBlob(_ *context.T, br BlobRef, rank uint64, _ ...rpc.CallOpt) error
+}
+
+// BlobManagerClientStub adds universal methods to BlobManagerClientMethods.
+type BlobManagerClientStub interface {
+ BlobManagerClientMethods
+ rpc.UniversalServiceMethods
+}
+
+// BlobManagerClient returns a client stub for BlobManager.
+func BlobManagerClient(name string) BlobManagerClientStub {
+ return implBlobManagerClientStub{name}
+}
+
+type implBlobManagerClientStub struct {
+ name string
+}
+
+func (c implBlobManagerClientStub) CreateBlob(ctx *context.T, opts ...rpc.CallOpt) (o0 BlobRef, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "CreateBlob", nil, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implBlobManagerClientStub) PutBlob(ctx *context.T, i0 BlobRef, opts ...rpc.CallOpt) (ocall BlobManagerPutBlobClientCall, err error) {
+ var call rpc.ClientCall
+ if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "PutBlob", []interface{}{i0}, opts...); err != nil {
+ return
+ }
+ ocall = &implBlobManagerPutBlobClientCall{ClientCall: call}
+ return
+}
+
+func (c implBlobManagerClientStub) CommitBlob(ctx *context.T, i0 BlobRef, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "CommitBlob", []interface{}{i0}, nil, opts...)
+ return
+}
+
+func (c implBlobManagerClientStub) GetBlobSize(ctx *context.T, i0 BlobRef, opts ...rpc.CallOpt) (o0 int64, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "GetBlobSize", []interface{}{i0}, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implBlobManagerClientStub) DeleteBlob(ctx *context.T, i0 BlobRef, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "DeleteBlob", []interface{}{i0}, nil, opts...)
+ return
+}
+
+func (c implBlobManagerClientStub) GetBlob(ctx *context.T, i0 BlobRef, i1 int64, opts ...rpc.CallOpt) (ocall BlobManagerGetBlobClientCall, err error) {
+ var call rpc.ClientCall
+ if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "GetBlob", []interface{}{i0, i1}, opts...); err != nil {
+ return
+ }
+ ocall = &implBlobManagerGetBlobClientCall{ClientCall: call}
+ return
+}
+
+func (c implBlobManagerClientStub) FetchBlob(ctx *context.T, i0 BlobRef, i1 uint64, opts ...rpc.CallOpt) (ocall BlobManagerFetchBlobClientCall, err error) {
+ var call rpc.ClientCall
+ if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "FetchBlob", []interface{}{i0, i1}, opts...); err != nil {
+ return
+ }
+ ocall = &implBlobManagerFetchBlobClientCall{ClientCall: call}
+ return
+}
+
+func (c implBlobManagerClientStub) PinBlob(ctx *context.T, i0 BlobRef, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "PinBlob", []interface{}{i0}, nil, opts...)
+ return
+}
+
+func (c implBlobManagerClientStub) UnpinBlob(ctx *context.T, i0 BlobRef, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "UnpinBlob", []interface{}{i0}, nil, opts...)
+ return
+}
+
+func (c implBlobManagerClientStub) KeepBlob(ctx *context.T, i0 BlobRef, i1 uint64, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "KeepBlob", []interface{}{i0, i1}, nil, opts...)
+ return
+}
+
+// BlobManagerPutBlobClientStream is the client stream for BlobManager.PutBlob.
+type BlobManagerPutBlobClientStream interface {
+ // SendStream returns the send side of the BlobManager.PutBlob client stream.
+ SendStream() interface {
+ // Send places the item onto the output stream. Returns errors
+ // encountered while sending, or if Send is called after Close or
+ // the stream has been canceled. Blocks if there is no buffer
+ // space; will unblock when buffer space is available or after
+ // the stream has been canceled.
+ Send(item []byte) error
+ // Close indicates to the server that no more items will be sent;
+ // server Recv calls will receive io.EOF after all sent items.
+ // This is an optional call - e.g. a client might call Close if it
+ // needs to continue receiving items from the server after it's
+ // done sending. Returns errors encountered while closing, or if
+ // Close is called after the stream has been canceled. Like Send,
+ // blocks if there is no buffer space available.
+ Close() error
+ }
+}
+
+// BlobManagerPutBlobClientCall represents the call returned from BlobManager.PutBlob.
+type BlobManagerPutBlobClientCall interface {
+ BlobManagerPutBlobClientStream
+ // Finish performs the equivalent of SendStream().Close, then blocks until
+ // the server is done, and returns the positional return values for the call.
+ //
+ // Finish returns immediately if the call has been canceled; depending on the
+ // timing the output could either be an error signaling cancelation, or the
+ // valid positional return values from the server.
+ //
+ // Calling Finish is mandatory for releasing stream resources, unless the call
+ // has been canceled or any of the other methods return an error. Finish should
+ // be called at most once.
+ Finish() error
+}
+
+type implBlobManagerPutBlobClientCall struct {
+ rpc.ClientCall
+}
+
+func (c *implBlobManagerPutBlobClientCall) SendStream() interface {
+ Send(item []byte) error
+ Close() error
+} {
+ return implBlobManagerPutBlobClientCallSend{c}
+}
+
+type implBlobManagerPutBlobClientCallSend struct {
+ c *implBlobManagerPutBlobClientCall
+}
+
+func (c implBlobManagerPutBlobClientCallSend) Send(item []byte) error {
+ return c.c.Send(item)
+}
+func (c implBlobManagerPutBlobClientCallSend) Close() error {
+ return c.c.CloseSend()
+}
+func (c *implBlobManagerPutBlobClientCall) Finish() (err error) {
+ err = c.ClientCall.Finish()
+ return
+}
+
+// BlobManagerGetBlobClientStream is the client stream for BlobManager.GetBlob.
+type BlobManagerGetBlobClientStream interface {
+ // RecvStream returns the receiver side of the BlobManager.GetBlob client stream.
+ RecvStream() interface {
+ // Advance stages an item so that it may be retrieved via Value. Returns
+ // true iff there is an item to retrieve. Advance must be called before
+ // Value is called. May block if an item is not available.
+ Advance() bool
+ // Value returns the item that was staged by Advance. May panic if Advance
+ // returned false or was not called. Never blocks.
+ Value() []byte
+ // Err returns any error encountered by Advance. Never blocks.
+ Err() error
+ }
+}
+
+// BlobManagerGetBlobClientCall represents the call returned from BlobManager.GetBlob.
+type BlobManagerGetBlobClientCall interface {
+ BlobManagerGetBlobClientStream
+ // Finish blocks until the server is done, and returns the positional return
+ // values for call.
+ //
+ // Finish returns immediately if the call has been canceled; depending on the
+ // timing the output could either be an error signaling cancelation, or the
+ // valid positional return values from the server.
+ //
+ // Calling Finish is mandatory for releasing stream resources, unless the call
+ // has been canceled or any of the other methods return an error. Finish should
+ // be called at most once.
+ Finish() error
+}
+
+type implBlobManagerGetBlobClientCall struct {
+ rpc.ClientCall
+ valRecv []byte
+ errRecv error
+}
+
+func (c *implBlobManagerGetBlobClientCall) RecvStream() interface {
+ Advance() bool
+ Value() []byte
+ Err() error
+} {
+ return implBlobManagerGetBlobClientCallRecv{c}
+}
+
+type implBlobManagerGetBlobClientCallRecv struct {
+ c *implBlobManagerGetBlobClientCall
+}
+
+func (c implBlobManagerGetBlobClientCallRecv) Advance() bool {
+ c.c.errRecv = c.c.Recv(&c.c.valRecv)
+ return c.c.errRecv == nil
+}
+func (c implBlobManagerGetBlobClientCallRecv) Value() []byte {
+ return c.c.valRecv
+}
+func (c implBlobManagerGetBlobClientCallRecv) Err() error {
+ if c.c.errRecv == io.EOF {
+ return nil
+ }
+ return c.c.errRecv
+}
+func (c *implBlobManagerGetBlobClientCall) Finish() (err error) {
+ err = c.ClientCall.Finish()
+ return
+}
+
+// BlobManagerFetchBlobClientStream is the client stream for BlobManager.FetchBlob.
+type BlobManagerFetchBlobClientStream interface {
+ // RecvStream returns the receiver side of the BlobManager.FetchBlob client stream.
+ RecvStream() interface {
+ // Advance stages an item so that it may be retrieved via Value. Returns
+ // true iff there is an item to retrieve. Advance must be called before
+ // Value is called. May block if an item is not available.
+ Advance() bool
+ // Value returns the item that was staged by Advance. May panic if Advance
+ // returned false or was not called. Never blocks.
+ Value() BlobFetchStatus
+ // Err returns any error encountered by Advance. Never blocks.
+ Err() error
+ }
+}
+
+// BlobManagerFetchBlobClientCall represents the call returned from BlobManager.FetchBlob.
+type BlobManagerFetchBlobClientCall interface {
+ BlobManagerFetchBlobClientStream
+ // Finish blocks until the server is done, and returns the positional return
+ // values for call.
+ //
+ // Finish returns immediately if the call has been canceled; depending on the
+ // timing the output could either be an error signaling cancelation, or the
+ // valid positional return values from the server.
+ //
+ // Calling Finish is mandatory for releasing stream resources, unless the call
+ // has been canceled or any of the other methods return an error. Finish should
+ // be called at most once.
+ Finish() error
+}
+
+type implBlobManagerFetchBlobClientCall struct {
+ rpc.ClientCall
+ valRecv BlobFetchStatus
+ errRecv error
+}
+
+func (c *implBlobManagerFetchBlobClientCall) RecvStream() interface {
+ Advance() bool
+ Value() BlobFetchStatus
+ Err() error
+} {
+ return implBlobManagerFetchBlobClientCallRecv{c}
+}
+
+type implBlobManagerFetchBlobClientCallRecv struct {
+ c *implBlobManagerFetchBlobClientCall
+}
+
+func (c implBlobManagerFetchBlobClientCallRecv) Advance() bool {
+ c.c.valRecv = BlobFetchStatus{}
+ c.c.errRecv = c.c.Recv(&c.c.valRecv)
+ return c.c.errRecv == nil
+}
+func (c implBlobManagerFetchBlobClientCallRecv) Value() BlobFetchStatus {
+ return c.c.valRecv
+}
+func (c implBlobManagerFetchBlobClientCallRecv) Err() error {
+ if c.c.errRecv == io.EOF {
+ return nil
+ }
+ return c.c.errRecv
+}
+func (c *implBlobManagerFetchBlobClientCall) Finish() (err error) {
+ err = c.ClientCall.Finish()
+ return
+}
+
+// BlobManagerServerMethods is the interface a server writer
+// implements for BlobManager.
+//
+// BlobManager is the interface for blob operations.
+//
+// Description of API for resumable blob creation (append-only):
+// - Up until commit, a BlobRef may be used with PutBlob, GetBlobSize,
+// DeleteBlob, and CommitBlob. Blob creation may be resumed by obtaining the
+// current blob size via GetBlobSize and appending to the blob via PutBlob.
+// - After commit, a blob is immutable, at which point PutBlob and CommitBlob
+// may no longer be used.
+// - All other methods (GetBlob, FetchBlob, PinBlob, etc.) may only be used
+// after commit.
+type BlobManagerServerMethods interface {
+ // CreateBlob returns a BlobRef for a newly created blob.
+ CreateBlob(*context.T, rpc.ServerCall) (br BlobRef, _ error)
+ // PutBlob appends the byte stream to the blob.
+ PutBlob(_ *context.T, _ BlobManagerPutBlobServerCall, br BlobRef) error
+ // CommitBlob marks the blob as immutable.
+ CommitBlob(_ *context.T, _ rpc.ServerCall, br BlobRef) error
+ // GetBlobSize returns the count of bytes written as part of the blob
+ // (committed or uncommitted).
+ GetBlobSize(_ *context.T, _ rpc.ServerCall, br BlobRef) (int64, error)
+ // DeleteBlob locally deletes the blob (committed or uncommitted).
+ DeleteBlob(_ *context.T, _ rpc.ServerCall, br BlobRef) error
+ // GetBlob returns the byte stream from a committed blob starting at offset.
+ GetBlob(_ *context.T, _ BlobManagerGetBlobServerCall, br BlobRef, offset int64) error
+ // FetchBlob initiates fetching a blob if not locally found. priority
+ // controls the network priority of the blob. Higher priority blobs are
+ // fetched before the lower priority ones. However, an ongoing blob
+ // transfer is not interrupted. Status updates are streamed back to the
+ // client as fetch is in progress.
+ FetchBlob(_ *context.T, _ BlobManagerFetchBlobServerCall, br BlobRef, priority uint64) error
+ // PinBlob locally pins the blob so that it is not evicted.
+ PinBlob(_ *context.T, _ rpc.ServerCall, br BlobRef) error
+ // UnpinBlob locally unpins the blob so that it can be evicted if needed.
+ UnpinBlob(_ *context.T, _ rpc.ServerCall, br BlobRef) error
+ // KeepBlob locally caches the blob with the specified rank. Lower
+ // ranked blobs are more eagerly evicted.
+ KeepBlob(_ *context.T, _ rpc.ServerCall, br BlobRef, rank uint64) error
+}
+
+// BlobManagerServerStubMethods is the server interface containing
+// BlobManager methods, as expected by rpc.Server.
+// The only difference between this interface and BlobManagerServerMethods
+// is the streaming methods.
+type BlobManagerServerStubMethods interface {
+ // CreateBlob returns a BlobRef for a newly created blob.
+ CreateBlob(*context.T, rpc.ServerCall) (br BlobRef, _ error)
+ // PutBlob appends the byte stream to the blob.
+ PutBlob(_ *context.T, _ *BlobManagerPutBlobServerCallStub, br BlobRef) error
+ // CommitBlob marks the blob as immutable.
+ CommitBlob(_ *context.T, _ rpc.ServerCall, br BlobRef) error
+ // GetBlobSize returns the count of bytes written as part of the blob
+ // (committed or uncommitted).
+ GetBlobSize(_ *context.T, _ rpc.ServerCall, br BlobRef) (int64, error)
+ // DeleteBlob locally deletes the blob (committed or uncommitted).
+ DeleteBlob(_ *context.T, _ rpc.ServerCall, br BlobRef) error
+ // GetBlob returns the byte stream from a committed blob starting at offset.
+ GetBlob(_ *context.T, _ *BlobManagerGetBlobServerCallStub, br BlobRef, offset int64) error
+ // FetchBlob initiates fetching a blob if not locally found. priority
+ // controls the network priority of the blob. Higher priority blobs are
+ // fetched before the lower priority ones. However, an ongoing blob
+ // transfer is not interrupted. Status updates are streamed back to the
+ // client as fetch is in progress.
+ FetchBlob(_ *context.T, _ *BlobManagerFetchBlobServerCallStub, br BlobRef, priority uint64) error
+ // PinBlob locally pins the blob so that it is not evicted.
+ PinBlob(_ *context.T, _ rpc.ServerCall, br BlobRef) error
+ // UnpinBlob locally unpins the blob so that it can be evicted if needed.
+ UnpinBlob(_ *context.T, _ rpc.ServerCall, br BlobRef) error
+ // KeepBlob locally caches the blob with the specified rank. Lower
+ // ranked blobs are more eagerly evicted.
+ KeepBlob(_ *context.T, _ rpc.ServerCall, br BlobRef, rank uint64) error
+}
+
+// BlobManagerServerStub adds universal methods to BlobManagerServerStubMethods.
+type BlobManagerServerStub interface {
+ BlobManagerServerStubMethods
+ // Describe the BlobManager interfaces.
+ Describe__() []rpc.InterfaceDesc
+}
+
+// BlobManagerServer returns a server stub for BlobManager.
+// It converts an implementation of BlobManagerServerMethods into
+// an object that may be used by rpc.Server.
+func BlobManagerServer(impl BlobManagerServerMethods) BlobManagerServerStub {
+ stub := implBlobManagerServerStub{
+ impl: impl,
+ }
+ // Initialize GlobState; always check the stub itself first, to handle the
+ // case where the user has the Glob method defined in their VDL source.
+ if gs := rpc.NewGlobState(stub); gs != nil {
+ stub.gs = gs
+ } else if gs := rpc.NewGlobState(impl); gs != nil {
+ stub.gs = gs
+ }
+ return stub
+}
+
+type implBlobManagerServerStub struct {
+ impl BlobManagerServerMethods
+ gs *rpc.GlobState
+}
+
+func (s implBlobManagerServerStub) CreateBlob(ctx *context.T, call rpc.ServerCall) (BlobRef, error) {
+ return s.impl.CreateBlob(ctx, call)
+}
+
+func (s implBlobManagerServerStub) PutBlob(ctx *context.T, call *BlobManagerPutBlobServerCallStub, i0 BlobRef) error {
+ return s.impl.PutBlob(ctx, call, i0)
+}
+
+func (s implBlobManagerServerStub) CommitBlob(ctx *context.T, call rpc.ServerCall, i0 BlobRef) error {
+ return s.impl.CommitBlob(ctx, call, i0)
+}
+
+func (s implBlobManagerServerStub) GetBlobSize(ctx *context.T, call rpc.ServerCall, i0 BlobRef) (int64, error) {
+ return s.impl.GetBlobSize(ctx, call, i0)
+}
+
+func (s implBlobManagerServerStub) DeleteBlob(ctx *context.T, call rpc.ServerCall, i0 BlobRef) error {
+ return s.impl.DeleteBlob(ctx, call, i0)
+}
+
+func (s implBlobManagerServerStub) GetBlob(ctx *context.T, call *BlobManagerGetBlobServerCallStub, i0 BlobRef, i1 int64) error {
+ return s.impl.GetBlob(ctx, call, i0, i1)
+}
+
+func (s implBlobManagerServerStub) FetchBlob(ctx *context.T, call *BlobManagerFetchBlobServerCallStub, i0 BlobRef, i1 uint64) error {
+ return s.impl.FetchBlob(ctx, call, i0, i1)
+}
+
+func (s implBlobManagerServerStub) PinBlob(ctx *context.T, call rpc.ServerCall, i0 BlobRef) error {
+ return s.impl.PinBlob(ctx, call, i0)
+}
+
+func (s implBlobManagerServerStub) UnpinBlob(ctx *context.T, call rpc.ServerCall, i0 BlobRef) error {
+ return s.impl.UnpinBlob(ctx, call, i0)
+}
+
+func (s implBlobManagerServerStub) KeepBlob(ctx *context.T, call rpc.ServerCall, i0 BlobRef, i1 uint64) error {
+ return s.impl.KeepBlob(ctx, call, i0, i1)
+}
+
+func (s implBlobManagerServerStub) Globber() *rpc.GlobState {
+ return s.gs
+}
+
+func (s implBlobManagerServerStub) Describe__() []rpc.InterfaceDesc {
+ return []rpc.InterfaceDesc{BlobManagerDesc}
+}
+
+// BlobManagerDesc describes the BlobManager interface.
+var BlobManagerDesc rpc.InterfaceDesc = descBlobManager
+
+// descBlobManager hides the desc to keep godoc clean.
+var descBlobManager = rpc.InterfaceDesc{
+ Name: "BlobManager",
+ PkgPath: "v.io/v23/services/syncbase/nosql",
+ Doc: "// BlobManager is the interface for blob operations.\n//\n// Description of API for resumable blob creation (append-only):\n// - Up until commit, a BlobRef may be used with PutBlob, GetBlobSize,\n// DeleteBlob, and CommitBlob. Blob creation may be resumed by obtaining the\n// current blob size via GetBlobSize and appending to the blob via PutBlob.\n// - After commit, a blob is immutable, at which point PutBlob and CommitBlob\n// may no longer be used.\n// - All other methods (GetBlob, FetchBlob, PinBlob, etc.) may only be used\n// after commit.",
+ Methods: []rpc.MethodDesc{
+ {
+ Name: "CreateBlob",
+ Doc: "// CreateBlob returns a BlobRef for a newly created blob.",
+ OutArgs: []rpc.ArgDesc{
+ {"br", ``}, // BlobRef
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "PutBlob",
+ Doc: "// PutBlob appends the byte stream to the blob.",
+ InArgs: []rpc.ArgDesc{
+ {"br", ``}, // BlobRef
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "CommitBlob",
+ Doc: "// CommitBlob marks the blob as immutable.",
+ InArgs: []rpc.ArgDesc{
+ {"br", ``}, // BlobRef
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "GetBlobSize",
+ Doc: "// GetBlobSize returns the count of bytes written as part of the blob\n// (committed or uncommitted).",
+ InArgs: []rpc.ArgDesc{
+ {"br", ``}, // BlobRef
+ },
+ OutArgs: []rpc.ArgDesc{
+ {"", ``}, // int64
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "DeleteBlob",
+ Doc: "// DeleteBlob locally deletes the blob (committed or uncommitted).",
+ InArgs: []rpc.ArgDesc{
+ {"br", ``}, // BlobRef
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "GetBlob",
+ Doc: "// GetBlob returns the byte stream from a committed blob starting at offset.",
+ InArgs: []rpc.ArgDesc{
+ {"br", ``}, // BlobRef
+ {"offset", ``}, // int64
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "FetchBlob",
+ Doc: "// FetchBlob initiates fetching a blob if not locally found. priority\n// controls the network priority of the blob. Higher priority blobs are\n// fetched before the lower priority ones. However, an ongoing blob\n// transfer is not interrupted. Status updates are streamed back to the\n// client as fetch is in progress.",
+ InArgs: []rpc.ArgDesc{
+ {"br", ``}, // BlobRef
+ {"priority", ``}, // uint64
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "PinBlob",
+ Doc: "// PinBlob locally pins the blob so that it is not evicted.",
+ InArgs: []rpc.ArgDesc{
+ {"br", ``}, // BlobRef
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "UnpinBlob",
+ Doc: "// UnpinBlob locally unpins the blob so that it can be evicted if needed.",
+ InArgs: []rpc.ArgDesc{
+ {"br", ``}, // BlobRef
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "KeepBlob",
+ Doc: "// KeepBlob locally caches the blob with the specified rank. Lower\n// ranked blobs are more eagerly evicted.",
+ InArgs: []rpc.ArgDesc{
+ {"br", ``}, // BlobRef
+ {"rank", ``}, // uint64
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ },
+}
+
+// BlobManagerPutBlobServerStream is the server stream for BlobManager.PutBlob.
+type BlobManagerPutBlobServerStream interface {
+ // RecvStream returns the receiver side of the BlobManager.PutBlob server stream.
+ RecvStream() interface {
+ // Advance stages an item so that it may be retrieved via Value. Returns
+ // true iff there is an item to retrieve. Advance must be called before
+ // Value is called. May block if an item is not available.
+ Advance() bool
+ // Value returns the item that was staged by Advance. May panic if Advance
+ // returned false or was not called. Never blocks.
+ Value() []byte
+ // Err returns any error encountered by Advance. Never blocks.
+ Err() error
+ }
+}
+
+// BlobManagerPutBlobServerCall represents the context passed to BlobManager.PutBlob.
+type BlobManagerPutBlobServerCall interface {
+ rpc.ServerCall
+ BlobManagerPutBlobServerStream
+}
+
+// BlobManagerPutBlobServerCallStub is a wrapper that converts rpc.StreamServerCall into
+// a typesafe stub that implements BlobManagerPutBlobServerCall.
+type BlobManagerPutBlobServerCallStub struct {
+ rpc.StreamServerCall
+ valRecv []byte
+ errRecv error
+}
+
+// Init initializes BlobManagerPutBlobServerCallStub from rpc.StreamServerCall.
+func (s *BlobManagerPutBlobServerCallStub) Init(call rpc.StreamServerCall) {
+ s.StreamServerCall = call
+}
+
+// RecvStream returns the receiver side of the BlobManager.PutBlob server stream.
+func (s *BlobManagerPutBlobServerCallStub) RecvStream() interface {
+ Advance() bool
+ Value() []byte
+ Err() error
+} {
+ return implBlobManagerPutBlobServerCallRecv{s}
+}
+
+type implBlobManagerPutBlobServerCallRecv struct {
+ s *BlobManagerPutBlobServerCallStub
+}
+
+func (s implBlobManagerPutBlobServerCallRecv) Advance() bool {
+ s.s.errRecv = s.s.Recv(&s.s.valRecv)
+ return s.s.errRecv == nil
+}
+func (s implBlobManagerPutBlobServerCallRecv) Value() []byte {
+ return s.s.valRecv
+}
+func (s implBlobManagerPutBlobServerCallRecv) Err() error {
+ if s.s.errRecv == io.EOF {
+ return nil
+ }
+ return s.s.errRecv
+}
+
+// BlobManagerGetBlobServerStream is the server stream for BlobManager.GetBlob.
+type BlobManagerGetBlobServerStream interface {
+ // SendStream returns the send side of the BlobManager.GetBlob server stream.
+ SendStream() interface {
+ // Send places the item onto the output stream. Returns errors encountered
+ // while sending. Blocks if there is no buffer space; will unblock when
+ // buffer space is available.
+ Send(item []byte) error
+ }
+}
+
+// BlobManagerGetBlobServerCall represents the context passed to BlobManager.GetBlob.
+type BlobManagerGetBlobServerCall interface {
+ rpc.ServerCall
+ BlobManagerGetBlobServerStream
+}
+
+// BlobManagerGetBlobServerCallStub is a wrapper that converts rpc.StreamServerCall into
+// a typesafe stub that implements BlobManagerGetBlobServerCall.
+type BlobManagerGetBlobServerCallStub struct {
+ rpc.StreamServerCall
+}
+
+// Init initializes BlobManagerGetBlobServerCallStub from rpc.StreamServerCall.
+func (s *BlobManagerGetBlobServerCallStub) Init(call rpc.StreamServerCall) {
+ s.StreamServerCall = call
+}
+
+// SendStream returns the send side of the BlobManager.GetBlob server stream.
+func (s *BlobManagerGetBlobServerCallStub) SendStream() interface {
+ Send(item []byte) error
+} {
+ return implBlobManagerGetBlobServerCallSend{s}
+}
+
+type implBlobManagerGetBlobServerCallSend struct {
+ s *BlobManagerGetBlobServerCallStub
+}
+
+func (s implBlobManagerGetBlobServerCallSend) Send(item []byte) error {
+ return s.s.Send(item)
+}
+
+// BlobManagerFetchBlobServerStream is the server stream for BlobManager.FetchBlob.
+type BlobManagerFetchBlobServerStream interface {
+ // SendStream returns the send side of the BlobManager.FetchBlob server stream.
+ SendStream() interface {
+ // Send places the item onto the output stream. Returns errors encountered
+ // while sending. Blocks if there is no buffer space; will unblock when
+ // buffer space is available.
+ Send(item BlobFetchStatus) error
+ }
+}
+
+// BlobManagerFetchBlobServerCall represents the context passed to BlobManager.FetchBlob.
+type BlobManagerFetchBlobServerCall interface {
+ rpc.ServerCall
+ BlobManagerFetchBlobServerStream
+}
+
+// BlobManagerFetchBlobServerCallStub is a wrapper that converts rpc.StreamServerCall into
+// a typesafe stub that implements BlobManagerFetchBlobServerCall.
+type BlobManagerFetchBlobServerCallStub struct {
+ rpc.StreamServerCall
+}
+
+// Init initializes BlobManagerFetchBlobServerCallStub from rpc.StreamServerCall.
+func (s *BlobManagerFetchBlobServerCallStub) Init(call rpc.StreamServerCall) {
+ s.StreamServerCall = call
+}
+
+// SendStream returns the send side of the BlobManager.FetchBlob server stream.
+func (s *BlobManagerFetchBlobServerCallStub) SendStream() interface {
+ Send(item BlobFetchStatus) error
+} {
+ return implBlobManagerFetchBlobServerCallSend{s}
+}
+
+type implBlobManagerFetchBlobServerCallSend struct {
+ s *BlobManagerFetchBlobServerCallStub
+}
+
+func (s implBlobManagerFetchBlobServerCallSend) Send(item BlobFetchStatus) error {
+ return s.s.Send(item)
+}
+
+// SchemaManagerClientMethods is the client interface
+// containing SchemaManager methods.
+//
+// SchemaManager implements the API for managing schema metadata attached
+// to a Database.
+type SchemaManagerClientMethods interface {
+ // GetSchemaMetadata retrieves schema metadata for this database.
+ //
+ // Requires: Client must have at least Read access on the Database.
+ GetSchemaMetadata(*context.T, ...rpc.CallOpt) (SchemaMetadata, error)
+ // SetSchemaMetadata stores schema metadata for this database.
+ //
+ // Requires: Client must have at least Write access on the Database.
+ SetSchemaMetadata(_ *context.T, metadata SchemaMetadata, _ ...rpc.CallOpt) error
+}
+
+// SchemaManagerClientStub adds universal methods to SchemaManagerClientMethods.
+type SchemaManagerClientStub interface {
+ SchemaManagerClientMethods
+ rpc.UniversalServiceMethods
+}
+
+// SchemaManagerClient returns a client stub for SchemaManager.
+func SchemaManagerClient(name string) SchemaManagerClientStub {
+ return implSchemaManagerClientStub{name}
+}
+
+type implSchemaManagerClientStub struct {
+ name string
+}
+
+func (c implSchemaManagerClientStub) GetSchemaMetadata(ctx *context.T, opts ...rpc.CallOpt) (o0 SchemaMetadata, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "GetSchemaMetadata", nil, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implSchemaManagerClientStub) SetSchemaMetadata(ctx *context.T, i0 SchemaMetadata, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "SetSchemaMetadata", []interface{}{i0}, nil, opts...)
+ return
+}
+
+// SchemaManagerServerMethods is the interface a server writer
+// implements for SchemaManager.
+//
+// SchemaManager implements the API for managing schema metadata attached
+// to a Database.
+type SchemaManagerServerMethods interface {
+ // GetSchemaMetadata retrieves schema metadata for this database.
+ //
+ // Requires: Client must have at least Read access on the Database.
+ GetSchemaMetadata(*context.T, rpc.ServerCall) (SchemaMetadata, error)
+ // SetSchemaMetadata stores schema metadata for this database.
+ //
+ // Requires: Client must have at least Write access on the Database.
+ SetSchemaMetadata(_ *context.T, _ rpc.ServerCall, metadata SchemaMetadata) error
+}
+
+// SchemaManagerServerStubMethods is the server interface containing
+// SchemaManager methods, as expected by rpc.Server.
+// There is no difference between this interface and SchemaManagerServerMethods
+// since there are no streaming methods.
+type SchemaManagerServerStubMethods SchemaManagerServerMethods
+
+// SchemaManagerServerStub adds universal methods to SchemaManagerServerStubMethods.
+type SchemaManagerServerStub interface {
+ SchemaManagerServerStubMethods
+ // Describe the SchemaManager interfaces.
+ Describe__() []rpc.InterfaceDesc
+}
+
+// SchemaManagerServer returns a server stub for SchemaManager.
+// It converts an implementation of SchemaManagerServerMethods into
+// an object that may be used by rpc.Server.
+func SchemaManagerServer(impl SchemaManagerServerMethods) SchemaManagerServerStub {
+ stub := implSchemaManagerServerStub{
+ impl: impl,
+ }
+ // Initialize GlobState; always check the stub itself first, to handle the
+ // case where the user has the Glob method defined in their VDL source.
+ if gs := rpc.NewGlobState(stub); gs != nil {
+ stub.gs = gs
+ } else if gs := rpc.NewGlobState(impl); gs != nil {
+ stub.gs = gs
+ }
+ return stub
+}
+
+type implSchemaManagerServerStub struct {
+ impl SchemaManagerServerMethods
+ gs *rpc.GlobState
+}
+
+func (s implSchemaManagerServerStub) GetSchemaMetadata(ctx *context.T, call rpc.ServerCall) (SchemaMetadata, error) {
+ return s.impl.GetSchemaMetadata(ctx, call)
+}
+
+func (s implSchemaManagerServerStub) SetSchemaMetadata(ctx *context.T, call rpc.ServerCall, i0 SchemaMetadata) error {
+ return s.impl.SetSchemaMetadata(ctx, call, i0)
+}
+
+func (s implSchemaManagerServerStub) Globber() *rpc.GlobState {
+ return s.gs
+}
+
+func (s implSchemaManagerServerStub) Describe__() []rpc.InterfaceDesc {
+ return []rpc.InterfaceDesc{SchemaManagerDesc}
+}
+
+// SchemaManagerDesc describes the SchemaManager interface.
+var SchemaManagerDesc rpc.InterfaceDesc = descSchemaManager
+
+// descSchemaManager hides the desc to keep godoc clean.
+var descSchemaManager = rpc.InterfaceDesc{
+ Name: "SchemaManager",
+ PkgPath: "v.io/v23/services/syncbase/nosql",
+ Doc: "// SchemaManager implements the API for managing schema metadata attached\n// to a Database.",
+ Methods: []rpc.MethodDesc{
+ {
+ Name: "GetSchemaMetadata",
+ Doc: "// GetSchemaMetadata retrieves schema metadata for this database.\n//\n// Requires: Client must have at least Read access on the Database.",
+ OutArgs: []rpc.ArgDesc{
+ {"", ``}, // SchemaMetadata
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "SetSchemaMetadata",
+ Doc: "// SetSchemaMetadata stores schema metadata for this database.\n//\n// Requires: Client must have at least Write access on the Database.",
+ InArgs: []rpc.ArgDesc{
+ {"metadata", ``}, // SchemaMetadata
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ },
+}
+
+// ConflictManagerClientMethods is the client interface
+// containing ConflictManager methods.
+//
+// ConflictManager interface provides all the methods necessary to handle
+// conflict resolution for a given database.
+type ConflictManagerClientMethods interface {
+ // StartConflictResolver registers a resolver for the database that is
+ // associated with this ConflictManager and creates a stream to receive
+ // conflicts and send resolutions.
+ // Batches of ConflictInfos will be sent over with the Continued field
+ // within the ConflictInfo representing the batch boundary. Client must
+ // respond with a batch of ResolutionInfos in the same fashion.
+ // A key is under conflict if two different values were written to it
+ // concurrently (in logical time), i.e. neither value is an ancestor of the
+ // other in the history graph.
+ // A key under conflict can be a part of a batch committed on local or
+ // remote or both syncbases. ConflictInfos for all keys in these two batches
+ // are grouped together. These keys may themselves be under conflict; the
+ // presented batch is a transitive closure of all batches containing keys
+ // under conflict.
+ // For example, for local batch {key1, key2} and remote batch {key1, key3},
+ // the batch sent for conflict resolution will be {key1, key2, key3}.
+ // If there was another concurrent batch {key2, key4}, then the batch sent
+ // for conflict resolution will be {key1, key2, key3, key4}.
+ StartConflictResolver(*context.T, ...rpc.CallOpt) (ConflictManagerStartConflictResolverClientCall, error)
+}
+
+// ConflictManagerClientStub adds universal methods to ConflictManagerClientMethods.
+type ConflictManagerClientStub interface {
+ ConflictManagerClientMethods
+ rpc.UniversalServiceMethods
+}
+
+// ConflictManagerClient returns a client stub for ConflictManager.
+func ConflictManagerClient(name string) ConflictManagerClientStub {
+ return implConflictManagerClientStub{name}
+}
+
+type implConflictManagerClientStub struct {
+ name string
+}
+
+func (c implConflictManagerClientStub) StartConflictResolver(ctx *context.T, opts ...rpc.CallOpt) (ocall ConflictManagerStartConflictResolverClientCall, err error) {
+ var call rpc.ClientCall
+ if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "StartConflictResolver", nil, opts...); err != nil {
+ return
+ }
+ ocall = &implConflictManagerStartConflictResolverClientCall{ClientCall: call}
+ return
+}
+
+// ConflictManagerStartConflictResolverClientStream is the client stream for ConflictManager.StartConflictResolver.
+type ConflictManagerStartConflictResolverClientStream interface {
+ // RecvStream returns the receiver side of the ConflictManager.StartConflictResolver client stream.
+ RecvStream() interface {
+ // Advance stages an item so that it may be retrieved via Value. Returns
+ // true iff there is an item to retrieve. Advance must be called before
+ // Value is called. May block if an item is not available.
+ Advance() bool
+ // Value returns the item that was staged by Advance. May panic if Advance
+ // returned false or was not called. Never blocks.
+ Value() ConflictInfo
+ // Err returns any error encountered by Advance. Never blocks.
+ Err() error
+ }
+ // SendStream returns the send side of the ConflictManager.StartConflictResolver client stream.
+ SendStream() interface {
+ // Send places the item onto the output stream. Returns errors
+ // encountered while sending, or if Send is called after Close or
+ // the stream has been canceled. Blocks if there is no buffer
+ // space; will unblock when buffer space is available or after
+ // the stream has been canceled.
+ Send(item ResolutionInfo) error
+ // Close indicates to the server that no more items will be sent;
+ // server Recv calls will receive io.EOF after all sent items.
+ // This is an optional call - e.g. a client might call Close if it
+ // needs to continue receiving items from the server after it's
+ // done sending. Returns errors encountered while closing, or if
+ // Close is called after the stream has been canceled. Like Send,
+ // blocks if there is no buffer space available.
+ Close() error
+ }
+}
+
+// ConflictManagerStartConflictResolverClientCall represents the call returned from ConflictManager.StartConflictResolver.
+type ConflictManagerStartConflictResolverClientCall interface {
+ ConflictManagerStartConflictResolverClientStream
+ // Finish performs the equivalent of SendStream().Close, then blocks until
+ // the server is done, and returns the positional return values for the call.
+ //
+ // Finish returns immediately if the call has been canceled; depending on the
+ // timing the output could either be an error signaling cancelation, or the
+ // valid positional return values from the server.
+ //
+ // Calling Finish is mandatory for releasing stream resources, unless the call
+ // has been canceled or any of the other methods return an error. Finish should
+ // be called at most once.
+ Finish() error
+}
+
+type implConflictManagerStartConflictResolverClientCall struct {
+ rpc.ClientCall
+ valRecv ConflictInfo
+ errRecv error
+}
+
+func (c *implConflictManagerStartConflictResolverClientCall) RecvStream() interface {
+ Advance() bool
+ Value() ConflictInfo
+ Err() error
+} {
+ return implConflictManagerStartConflictResolverClientCallRecv{c}
+}
+
+type implConflictManagerStartConflictResolverClientCallRecv struct {
+ c *implConflictManagerStartConflictResolverClientCall
+}
+
+func (c implConflictManagerStartConflictResolverClientCallRecv) Advance() bool {
+ c.c.valRecv = ConflictInfo{}
+ c.c.errRecv = c.c.Recv(&c.c.valRecv)
+ return c.c.errRecv == nil
+}
+func (c implConflictManagerStartConflictResolverClientCallRecv) Value() ConflictInfo {
+ return c.c.valRecv
+}
+func (c implConflictManagerStartConflictResolverClientCallRecv) Err() error {
+ if c.c.errRecv == io.EOF {
+ return nil
+ }
+ return c.c.errRecv
+}
+func (c *implConflictManagerStartConflictResolverClientCall) SendStream() interface {
+ Send(item ResolutionInfo) error
+ Close() error
+} {
+ return implConflictManagerStartConflictResolverClientCallSend{c}
+}
+
+type implConflictManagerStartConflictResolverClientCallSend struct {
+ c *implConflictManagerStartConflictResolverClientCall
+}
+
+func (c implConflictManagerStartConflictResolverClientCallSend) Send(item ResolutionInfo) error {
+ return c.c.Send(item)
+}
+func (c implConflictManagerStartConflictResolverClientCallSend) Close() error {
+ return c.c.CloseSend()
+}
+func (c *implConflictManagerStartConflictResolverClientCall) Finish() (err error) {
+ err = c.ClientCall.Finish()
+ return
+}
+
+// ConflictManagerServerMethods is the interface a server writer
+// implements for ConflictManager.
+//
+// ConflictManager interface provides all the methods necessary to handle
+// conflict resolution for a given database.
+type ConflictManagerServerMethods interface {
+ // StartConflictResolver registers a resolver for the database that is
+ // associated with this ConflictManager and creates a stream to receive
+ // conflicts and send resolutions.
+ // Batches of ConflictInfos will be sent over with the Continued field
+ // within the ConflictInfo representing the batch boundary. Client must
+ // respond with a batch of ResolutionInfos in the same fashion.
+ // A key is under conflict if two different values were written to it
+ // concurrently (in logical time), i.e. neither value is an ancestor of the
+ // other in the history graph.
+ // A key under conflict can be a part of a batch committed on local or
+ // remote or both syncbases. ConflictInfos for all keys in these two batches
+ // are grouped together. These keys may themselves be under conflict; the
+ // presented batch is a transitive closure of all batches containing keys
+ // under conflict.
+ // For example, for local batch {key1, key2} and remote batch {key1, key3},
+ // the batch sent for conflict resolution will be {key1, key2, key3}.
+ // If there was another concurrent batch {key2, key4}, then the batch sent
+ // for conflict resolution will be {key1, key2, key3, key4}.
+ StartConflictResolver(*context.T, ConflictManagerStartConflictResolverServerCall) error
+}
+
+// ConflictManagerServerStubMethods is the server interface containing
+// ConflictManager methods, as expected by rpc.Server.
+// The only difference between this interface and ConflictManagerServerMethods
+// is the streaming methods.
+type ConflictManagerServerStubMethods interface {
+ // StartConflictResolver registers a resolver for the database that is
+ // associated with this ConflictManager and creates a stream to receive
+ // conflicts and send resolutions.
+ // Batches of ConflictInfos will be sent over with the Continued field
+ // within the ConflictInfo representing the batch boundary. Client must
+ // respond with a batch of ResolutionInfos in the same fashion.
+ // A key is under conflict if two different values were written to it
+ // concurrently (in logical time), i.e. neither value is an ancestor of the
+ // other in the history graph.
+ // A key under conflict can be a part of a batch committed on local or
+ // remote or both syncbases. ConflictInfos for all keys in these two batches
+ // are grouped together. These keys may themselves be under conflict; the
+ // presented batch is a transitive closure of all batches containing keys
+ // under conflict.
+ // For example, for local batch {key1, key2} and remote batch {key1, key3},
+ // the batch sent for conflict resolution will be {key1, key2, key3}.
+ // If there was another concurrent batch {key2, key4}, then the batch sent
+ // for conflict resolution will be {key1, key2, key3, key4}.
+ StartConflictResolver(*context.T, *ConflictManagerStartConflictResolverServerCallStub) error
+}
+
+// ConflictManagerServerStub adds universal methods to ConflictManagerServerStubMethods.
+type ConflictManagerServerStub interface {
+ ConflictManagerServerStubMethods
+ // Describe the ConflictManager interfaces.
+ Describe__() []rpc.InterfaceDesc
+}
+
+// ConflictManagerServer returns a server stub for ConflictManager.
+// It converts an implementation of ConflictManagerServerMethods into
+// an object that may be used by rpc.Server.
+func ConflictManagerServer(impl ConflictManagerServerMethods) ConflictManagerServerStub {
+ stub := implConflictManagerServerStub{
+ impl: impl,
+ }
+ // Initialize GlobState; always check the stub itself first, to handle the
+ // case where the user has the Glob method defined in their VDL source.
+ if gs := rpc.NewGlobState(stub); gs != nil {
+ stub.gs = gs
+ } else if gs := rpc.NewGlobState(impl); gs != nil {
+ stub.gs = gs
+ }
+ return stub
+}
+
+type implConflictManagerServerStub struct {
+ impl ConflictManagerServerMethods
+ gs *rpc.GlobState
+}
+
+func (s implConflictManagerServerStub) StartConflictResolver(ctx *context.T, call *ConflictManagerStartConflictResolverServerCallStub) error {
+ return s.impl.StartConflictResolver(ctx, call)
+}
+
+func (s implConflictManagerServerStub) Globber() *rpc.GlobState {
+ return s.gs
+}
+
+func (s implConflictManagerServerStub) Describe__() []rpc.InterfaceDesc {
+ return []rpc.InterfaceDesc{ConflictManagerDesc}
+}
+
+// ConflictManagerDesc describes the ConflictManager interface.
+var ConflictManagerDesc rpc.InterfaceDesc = descConflictManager
+
+// descConflictManager hides the desc to keep godoc clean.
+var descConflictManager = rpc.InterfaceDesc{
+ Name: "ConflictManager",
+ PkgPath: "v.io/v23/services/syncbase/nosql",
+ Doc: "// ConflictManager interface provides all the methods necessary to handle\n// conflict resolution for a given database.",
+ Methods: []rpc.MethodDesc{
+ {
+ Name: "StartConflictResolver",
+ Doc: "// StartConflictResolver registers a resolver for the database that is\n// associated with this ConflictManager and creates a stream to receive\n// conflicts and send resolutions.\n// Batches of ConflictInfos will be sent over with the Continued field\n// within the ConflictInfo representing the batch boundary. Client must\n// respond with a batch of ResolutionInfos in the same fashion.\n// A key is under conflict if two different values were written to it\n// concurrently (in logical time), i.e. neither value is an ancestor of the\n// other in the history graph.\n// A key under conflict can be a part of a batch committed on local or\n// remote or both syncbases. ConflictInfos for all keys in these two batches\n// are grouped together. These keys may themselves be under conflict; the\n// presented batch is a transitive closure of all batches containing keys\n// under conflict.\n// For example, for local batch {key1, key2} and remote batch {key1, key3},\n// the batch sent for conflict resolution will be {key1, key2, key3}.\n// If there was another concurrent batch {key2, key4}, then the batch sent\n// for conflict resolution will be {key1, key2, key3, key4}.",
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ },
+}
+
+// ConflictManagerStartConflictResolverServerStream is the server stream for ConflictManager.StartConflictResolver.
+type ConflictManagerStartConflictResolverServerStream interface {
+ // RecvStream returns the receiver side of the ConflictManager.StartConflictResolver server stream.
+ RecvStream() interface {
+ // Advance stages an item so that it may be retrieved via Value. Returns
+ // true iff there is an item to retrieve. Advance must be called before
+ // Value is called. May block if an item is not available.
+ Advance() bool
+ // Value returns the item that was staged by Advance. May panic if Advance
+ // returned false or was not called. Never blocks.
+ Value() ResolutionInfo
+ // Err returns any error encountered by Advance. Never blocks.
+ Err() error
+ }
+ // SendStream returns the send side of the ConflictManager.StartConflictResolver server stream.
+ SendStream() interface {
+ // Send places the item onto the output stream. Returns errors encountered
+ // while sending. Blocks if there is no buffer space; will unblock when
+ // buffer space is available.
+ Send(item ConflictInfo) error
+ }
+}
+
+// ConflictManagerStartConflictResolverServerCall represents the context passed to ConflictManager.StartConflictResolver.
+type ConflictManagerStartConflictResolverServerCall interface {
+ rpc.ServerCall
+ ConflictManagerStartConflictResolverServerStream
+}
+
+// ConflictManagerStartConflictResolverServerCallStub is a wrapper that converts rpc.StreamServerCall into
+// a typesafe stub that implements ConflictManagerStartConflictResolverServerCall.
+type ConflictManagerStartConflictResolverServerCallStub struct {
+ rpc.StreamServerCall
+ valRecv ResolutionInfo
+ errRecv error
+}
+
+// Init initializes ConflictManagerStartConflictResolverServerCallStub from rpc.StreamServerCall.
+func (s *ConflictManagerStartConflictResolverServerCallStub) Init(call rpc.StreamServerCall) {
+ s.StreamServerCall = call
+}
+
+// RecvStream returns the receiver side of the ConflictManager.StartConflictResolver server stream.
+func (s *ConflictManagerStartConflictResolverServerCallStub) RecvStream() interface {
+ Advance() bool
+ Value() ResolutionInfo
+ Err() error
+} {
+ return implConflictManagerStartConflictResolverServerCallRecv{s}
+}
+
+type implConflictManagerStartConflictResolverServerCallRecv struct {
+ s *ConflictManagerStartConflictResolverServerCallStub
+}
+
+func (s implConflictManagerStartConflictResolverServerCallRecv) Advance() bool {
+ s.s.valRecv = ResolutionInfo{}
+ s.s.errRecv = s.s.Recv(&s.s.valRecv)
+ return s.s.errRecv == nil
+}
+func (s implConflictManagerStartConflictResolverServerCallRecv) Value() ResolutionInfo {
+ return s.s.valRecv
+}
+func (s implConflictManagerStartConflictResolverServerCallRecv) Err() error {
+ if s.s.errRecv == io.EOF {
+ return nil
+ }
+ return s.s.errRecv
+}
+
+// SendStream returns the send side of the ConflictManager.StartConflictResolver server stream.
+func (s *ConflictManagerStartConflictResolverServerCallStub) SendStream() interface {
+ Send(item ConflictInfo) error
+} {
+ return implConflictManagerStartConflictResolverServerCallSend{s}
+}
+
+type implConflictManagerStartConflictResolverServerCallSend struct {
+ s *ConflictManagerStartConflictResolverServerCallStub
+}
+
+func (s implConflictManagerStartConflictResolverServerCallSend) Send(item ConflictInfo) error {
+ return s.s.Send(item)
+}
+
+// DatabaseClientMethods is the client interface
+// containing Database methods.
+//
+// Database represents a collection of Tables. Batches, queries, sync, watch,
+// etc. all operate at the Database level.
+// Database.Glob operates over Table names.
+// Param schemaVersion is the version number that the client expects the
+// database to be at. To disable schema version checking, pass -1.
+type DatabaseClientMethods interface {
+ // Object provides access control for Vanadium objects.
+ //
+ // Vanadium services implementing dynamic access control would typically embed
+ // this interface and tag additional methods defined by the service with one of
+ // Admin, Read, Write, Resolve etc. For example, the VDL definition of the
+ // object would be:
+ //
+ // package mypackage
+ //
+ // import "v.io/v23/security/access"
+ // import "v.io/v23/services/permissions"
+ //
+ // type MyObject interface {
+ // permissions.Object
+ // MyRead() (string, error) {access.Read}
+ // MyWrite(string) error {access.Write}
+ // }
+ //
+ // If the set of pre-defined tags is insufficient, services may define their
+ // own tag type and annotate all methods with this new type.
+ //
+ // Instead of embedding this Object interface, define SetPermissions and
+ // GetPermissions in their own interface. Authorization policies will typically
+ // respect annotations of a single type. For example, the VDL definition of an
+ // object would be:
+ //
+ // package mypackage
+ //
+ // import "v.io/v23/security/access"
+ //
+ // type MyTag string
+ //
+ // const (
+ // Blue = MyTag("Blue")
+ // Red = MyTag("Red")
+ // )
+ //
+ // type MyObject interface {
+ // MyMethod() (string, error) {Blue}
+ //
+ // // Allow clients to change access via the access.Object interface:
+ // SetPermissions(perms access.Permissions, version string) error {Red}
+ // GetPermissions() (perms access.Permissions, version string, err error) {Blue}
+ // }
+ permissions.ObjectClientMethods
+ // DatabaseWatcher allows a client to watch for updates to the database. For
+ // each watch request, the client will receive a reliable stream of watch events
+ // without re-ordering. See watch.GlobWatcher for a detailed explanation of the
+ // behavior.
+ // TODO(rogulenko): Currently the only supported watch patterns are
+ // "<tableName>/<rowPrefix>*". Consider changing that.
+ //
+ // Watching is done by starting a streaming RPC. The RPC takes a ResumeMarker
+ // argument that points to a particular place in the database event log. If an
+ // empty ResumeMarker is provided, the WatchStream will begin with a Change
+ // batch containing the initial state. Otherwise, the WatchStream will contain
+ // only changes since the provided ResumeMarker.
+ //
+ // The result stream consists of a never-ending sequence of Change messages
+ // (until the call fails or is canceled). Each Change contains the Name field
+ // in the form "<tableName>/<rowKey>" and the Value field of the StoreChange
+ // type. If the client has no access to a row specified in a change, that change
+ // is excluded from the result stream.
+ //
+ // Note: A single Watch Change batch may contain changes from more than one
+ // batch as originally committed on a remote Syncbase or obtained from conflict
+ // resolution. However, changes from a single original batch will always appear
+ // in the same Change batch.
+ DatabaseWatcherClientMethods
+ // SyncgroupManager is the interface for syncgroup operations.
+ // TODO(hpucha): Add blessings to create/join and add a refresh method.
+ SyncgroupManagerClientMethods
+ // BlobManager is the interface for blob operations.
+ //
+ // Description of API for resumable blob creation (append-only):
+ // - Up until commit, a BlobRef may be used with PutBlob, GetBlobSize,
+ // DeleteBlob, and CommitBlob. Blob creation may be resumed by obtaining the
+ // current blob size via GetBlobSize and appending to the blob via PutBlob.
+ // - After commit, a blob is immutable, at which point PutBlob and CommitBlob
+ // may no longer be used.
+ // - All other methods (GetBlob, FetchBlob, PinBlob, etc.) may only be used
+ // after commit.
+ BlobManagerClientMethods
+ // SchemaManager implements the API for managing schema metadata attached
+ // to a Database.
+ SchemaManagerClientMethods
+ // ConflictManager interface provides all the methods necessary to handle
+ // conflict resolution for a given database.
+ ConflictManagerClientMethods
+ // Create creates this Database.
+ // If perms is nil, we inherit (copy) the App perms.
+ // Create requires the caller to have Write permission at the App.
+ Create(_ *context.T, metadata *SchemaMetadata, perms access.Permissions, _ ...rpc.CallOpt) error
+ // Destroy destroys this Database, permanently removing all of its data.
+ Destroy(_ *context.T, schemaVersion int32, _ ...rpc.CallOpt) error
+ // Exists returns true only if this Database exists. Insufficient permissions
+ // cause Exists to return false instead of an error.
+ // TODO(ivanpi): Exists may fail with an error if higher levels of hierarchy
+ // do not exist.
+ Exists(_ *context.T, schemaVersion int32, _ ...rpc.CallOpt) (bool, error)
+ // ListTables returns a list of all Table names.
+ // This method exists on Database but not on Service or App because for the
+ // latter we can simply use glob, while for the former glob fails on
+ // BatchDatabase since we encode the batch id in the BatchDatabase object
+ // name. More specifically, the glob client library appears to have two odd
+ // behaviors:
+ // 1) It checks Resolve access on every component along the path (by doing a
+ // Dispatcher.Lookup), whereas this doesn't happen for other RPCs.
+ // 2) It does a Glob(<prefix>/*) for every prefix path, and only proceeds to
+ // the next path component if that component appeared in its parent's Glob
+ // results. This is inefficient in general, and broken for us since
+ // Glob("app/*") does not return batch database names like "a/d##bId".
+ // TODO(sadovsky): Maybe switch to streaming RPC.
+ ListTables(*context.T, ...rpc.CallOpt) ([]string, error)
+ // Exec executes a syncQL query with positional parameters and returns all
+ // results as specified by the query's select/delete statement.
+ // Concurrency semantics are documented in model.go.
+ Exec(_ *context.T, schemaVersion int32, query string, params []*vom.RawBytes, _ ...rpc.CallOpt) (DatabaseExecClientCall, error)
+ // BeginBatch creates a new batch. It returns a "batch suffix" string to
+ // append to the object name of this Database, yielding an object name for the
+ // Database bound to the created batch. (For example, if this Database is
+ // named "/path/to/db" and BeginBatch returns "##abc", the client should
+ // construct batch Database object name "/path/to/db##abc".) If this Database
+ // is already bound to a batch, BeginBatch() will fail with ErrBoundToBatch.
+ // Concurrency semantics are documented in model.go.
+ // TODO(sadovsky): Maybe make BatchOptions optional. Also, rename it to 'opts'
+ // everywhere now that v.io/i/912 is resolved.
+ BeginBatch(_ *context.T, schemaVersion int32, bo BatchOptions, _ ...rpc.CallOpt) (string, error)
+ // Commit persists the pending changes to the database.
+ // If this Database is not bound to a batch, Commit() will fail with
+ // ErrNotBoundToBatch.
+ Commit(_ *context.T, schemaVersion int32, _ ...rpc.CallOpt) error
+ // Abort notifies the server that any pending changes can be discarded.
+ // It is not strictly required, but it may allow the server to release locks
+ // or other resources sooner than if it was not called.
+ // If this Database is not bound to a batch, Abort() will fail with
+ // ErrNotBoundToBatch.
+ Abort(_ *context.T, schemaVersion int32, _ ...rpc.CallOpt) error
+ // PauseSync pauses sync for this database. Incoming sync, as well as
+ // outgoing sync of subsequent writes, will be disabled until ResumeSync
+ // is called. PauseSync is idempotent.
+ PauseSync(*context.T, ...rpc.CallOpt) error
+ // ResumeSync resumes sync for this database. ResumeSync is idempotent.
+ ResumeSync(*context.T, ...rpc.CallOpt) error
+}
+
+// DatabaseClientStub adds universal methods to DatabaseClientMethods.
+type DatabaseClientStub interface {
+ DatabaseClientMethods
+ rpc.UniversalServiceMethods
+}
+
+// DatabaseClient returns a client stub for Database.
+func DatabaseClient(name string) DatabaseClientStub {
+ return implDatabaseClientStub{name, permissions.ObjectClient(name), DatabaseWatcherClient(name), SyncgroupManagerClient(name), BlobManagerClient(name), SchemaManagerClient(name), ConflictManagerClient(name)}
+}
+
+type implDatabaseClientStub struct {
+ name string
+
+ permissions.ObjectClientStub
+ DatabaseWatcherClientStub
+ SyncgroupManagerClientStub
+ BlobManagerClientStub
+ SchemaManagerClientStub
+ ConflictManagerClientStub
+}
+
+func (c implDatabaseClientStub) Create(ctx *context.T, i0 *SchemaMetadata, i1 access.Permissions, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "Create", []interface{}{i0, i1}, nil, opts...)
+ return
+}
+
+func (c implDatabaseClientStub) Destroy(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "Destroy", []interface{}{i0}, nil, opts...)
+ return
+}
+
+func (c implDatabaseClientStub) Exists(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (o0 bool, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "Exists", []interface{}{i0}, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implDatabaseClientStub) ListTables(ctx *context.T, opts ...rpc.CallOpt) (o0 []string, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "ListTables", nil, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implDatabaseClientStub) Exec(ctx *context.T, i0 int32, i1 string, i2 []*vom.RawBytes, opts ...rpc.CallOpt) (ocall DatabaseExecClientCall, err error) {
+ var call rpc.ClientCall
+ if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "Exec", []interface{}{i0, i1, i2}, opts...); err != nil {
+ return
+ }
+ ocall = &implDatabaseExecClientCall{ClientCall: call}
+ return
+}
+
+func (c implDatabaseClientStub) BeginBatch(ctx *context.T, i0 int32, i1 BatchOptions, opts ...rpc.CallOpt) (o0 string, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "BeginBatch", []interface{}{i0, i1}, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implDatabaseClientStub) Commit(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "Commit", []interface{}{i0}, nil, opts...)
+ return
+}
+
+func (c implDatabaseClientStub) Abort(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "Abort", []interface{}{i0}, nil, opts...)
+ return
+}
+
+func (c implDatabaseClientStub) PauseSync(ctx *context.T, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "PauseSync", nil, nil, opts...)
+ return
+}
+
+func (c implDatabaseClientStub) ResumeSync(ctx *context.T, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "ResumeSync", nil, nil, opts...)
+ return
+}
+
+// DatabaseExecClientStream is the client stream for Database.Exec.
+type DatabaseExecClientStream interface {
+ // RecvStream returns the receiver side of the Database.Exec client stream.
+ RecvStream() interface {
+ // Advance stages an item so that it may be retrieved via Value. Returns
+ // true iff there is an item to retrieve. Advance must be called before
+ // Value is called. May block if an item is not available.
+ Advance() bool
+ // Value returns the item that was staged by Advance. May panic if Advance
+ // returned false or was not called. Never blocks.
+ Value() []*vom.RawBytes
+ // Err returns any error encountered by Advance. Never blocks.
+ Err() error
+ }
+}
+
+// DatabaseExecClientCall represents the call returned from Database.Exec.
+type DatabaseExecClientCall interface {
+ DatabaseExecClientStream
+ // Finish blocks until the server is done, and returns the positional return
+ // values for call.
+ //
+ // Finish returns immediately if the call has been canceled; depending on the
+ // timing the output could either be an error signaling cancelation, or the
+ // valid positional return values from the server.
+ //
+ // Calling Finish is mandatory for releasing stream resources, unless the call
+ // has been canceled or any of the other methods return an error. Finish should
+ // be called at most once.
+ Finish() error
+}
+
+type implDatabaseExecClientCall struct {
+ rpc.ClientCall
+ valRecv []*vom.RawBytes
+ errRecv error
+}
+
+func (c *implDatabaseExecClientCall) RecvStream() interface {
+ Advance() bool
+ Value() []*vom.RawBytes
+ Err() error
+} {
+ return implDatabaseExecClientCallRecv{c}
+}
+
+type implDatabaseExecClientCallRecv struct {
+ c *implDatabaseExecClientCall
+}
+
+func (c implDatabaseExecClientCallRecv) Advance() bool {
+ c.c.errRecv = c.c.Recv(&c.c.valRecv)
+ return c.c.errRecv == nil
+}
+func (c implDatabaseExecClientCallRecv) Value() []*vom.RawBytes {
+ return c.c.valRecv
+}
+func (c implDatabaseExecClientCallRecv) Err() error {
+ if c.c.errRecv == io.EOF {
+ return nil
+ }
+ return c.c.errRecv
+}
+func (c *implDatabaseExecClientCall) Finish() (err error) {
+ err = c.ClientCall.Finish()
+ return
+}
+
+// DatabaseServerMethods is the interface a server writer
+// implements for Database.
+//
+// Database represents a collection of Tables. Batches, queries, sync, watch,
+// etc. all operate at the Database level.
+// Database.Glob operates over Table names.
+// Param schemaVersion is the version number that the client expects the
+// database to be at. To disable schema version checking, pass -1.
+type DatabaseServerMethods interface {
+ // Object provides access control for Vanadium objects.
+ //
+ // Vanadium services implementing dynamic access control would typically embed
+ // this interface and tag additional methods defined by the service with one of
+ // Admin, Read, Write, Resolve etc. For example, the VDL definition of the
+ // object would be:
+ //
+ // package mypackage
+ //
+ // import "v.io/v23/security/access"
+ // import "v.io/v23/services/permissions"
+ //
+ // type MyObject interface {
+ // permissions.Object
+ // MyRead() (string, error) {access.Read}
+ // MyWrite(string) error {access.Write}
+ // }
+ //
+ // If the set of pre-defined tags is insufficient, services may define their
+ // own tag type and annotate all methods with this new type.
+ //
+ // Instead of embedding this Object interface, define SetPermissions and
+ // GetPermissions in their own interface. Authorization policies will typically
+ // respect annotations of a single type. For example, the VDL definition of an
+ // object would be:
+ //
+ // package mypackage
+ //
+ // import "v.io/v23/security/access"
+ //
+ // type MyTag string
+ //
+ // const (
+ // Blue = MyTag("Blue")
+ // Red = MyTag("Red")
+ // )
+ //
+ // type MyObject interface {
+ // MyMethod() (string, error) {Blue}
+ //
+ // // Allow clients to change access via the access.Object interface:
+ // SetPermissions(perms access.Permissions, version string) error {Red}
+ // GetPermissions() (perms access.Permissions, version string, err error) {Blue}
+ // }
+ permissions.ObjectServerMethods
+ // DatabaseWatcher allows a client to watch for updates to the database. For
+ // each watch request, the client will receive a reliable stream of watch events
+ // without re-ordering. See watch.GlobWatcher for a detailed explanation of the
+ // behavior.
+ // TODO(rogulenko): Currently the only supported watch patterns are
+ // "<tableName>/<rowPrefix>*". Consider changing that.
+ //
+ // Watching is done by starting a streaming RPC. The RPC takes a ResumeMarker
+ // argument that points to a particular place in the database event log. If an
+ // empty ResumeMarker is provided, the WatchStream will begin with a Change
+ // batch containing the initial state. Otherwise, the WatchStream will contain
+ // only changes since the provided ResumeMarker.
+ //
+ // The result stream consists of a never-ending sequence of Change messages
+ // (until the call fails or is canceled). Each Change contains the Name field
+ // in the form "<tableName>/<rowKey>" and the Value field of the StoreChange
+ // type. If the client has no access to a row specified in a change, that change
+ // is excluded from the result stream.
+ //
+ // Note: A single Watch Change batch may contain changes from more than one
+ // batch as originally committed on a remote Syncbase or obtained from conflict
+ // resolution. However, changes from a single original batch will always appear
+ // in the same Change batch.
+ DatabaseWatcherServerMethods
+ // SyncgroupManager is the interface for syncgroup operations.
+ // TODO(hpucha): Add blessings to create/join and add a refresh method.
+ SyncgroupManagerServerMethods
+ // BlobManager is the interface for blob operations.
+ //
+ // Description of API for resumable blob creation (append-only):
+ // - Up until commit, a BlobRef may be used with PutBlob, GetBlobSize,
+ // DeleteBlob, and CommitBlob. Blob creation may be resumed by obtaining the
+ // current blob size via GetBlobSize and appending to the blob via PutBlob.
+ // - After commit, a blob is immutable, at which point PutBlob and CommitBlob
+ // may no longer be used.
+ // - All other methods (GetBlob, FetchBlob, PinBlob, etc.) may only be used
+ // after commit.
+ BlobManagerServerMethods
+ // SchemaManager implements the API for managing schema metadata attached
+ // to a Database.
+ SchemaManagerServerMethods
+ // ConflictManager interface provides all the methods necessary to handle
+ // conflict resolution for a given database.
+ ConflictManagerServerMethods
+ // Create creates this Database.
+ // If perms is nil, we inherit (copy) the App perms.
+ // Create requires the caller to have Write permission at the App.
+ Create(_ *context.T, _ rpc.ServerCall, metadata *SchemaMetadata, perms access.Permissions) error
+ // Destroy destroys this Database, permanently removing all of its data.
+ Destroy(_ *context.T, _ rpc.ServerCall, schemaVersion int32) error
+ // Exists returns true only if this Database exists. Insufficient permissions
+ // cause Exists to return false instead of an error.
+ // TODO(ivanpi): Exists may fail with an error if higher levels of hierarchy
+ // do not exist.
+ Exists(_ *context.T, _ rpc.ServerCall, schemaVersion int32) (bool, error)
+ // ListTables returns a list of all Table names.
+ // This method exists on Database but not on Service or App because for the
+ // latter we can simply use glob, while for the former glob fails on
+ // BatchDatabase since we encode the batch id in the BatchDatabase object
+ // name. More specifically, the glob client library appears to have two odd
+ // behaviors:
+ // 1) It checks Resolve access on every component along the path (by doing a
+ // Dispatcher.Lookup), whereas this doesn't happen for other RPCs.
+ // 2) It does a Glob(<prefix>/*) for every prefix path, and only proceeds to
+ // the next path component if that component appeared in its parent's Glob
+ // results. This is inefficient in general, and broken for us since
+ // Glob("app/*") does not return batch database names like "a/d##bId".
+ // TODO(sadovsky): Maybe switch to streaming RPC.
+ ListTables(*context.T, rpc.ServerCall) ([]string, error)
+ // Exec executes a syncQL query with positional parameters and returns all
+ // results as specified by the query's select/delete statement.
+ // Concurrency semantics are documented in model.go.
+ Exec(_ *context.T, _ DatabaseExecServerCall, schemaVersion int32, query string, params []*vom.RawBytes) error
+ // BeginBatch creates a new batch. It returns a "batch suffix" string to
+ // append to the object name of this Database, yielding an object name for the
+ // Database bound to the created batch. (For example, if this Database is
+ // named "/path/to/db" and BeginBatch returns "##abc", the client should
+ // construct batch Database object name "/path/to/db##abc".) If this Database
+ // is already bound to a batch, BeginBatch() will fail with ErrBoundToBatch.
+ // Concurrency semantics are documented in model.go.
+ // TODO(sadovsky): Maybe make BatchOptions optional. Also, rename it to 'opts'
+ // everywhere now that v.io/i/912 is resolved.
+ BeginBatch(_ *context.T, _ rpc.ServerCall, schemaVersion int32, bo BatchOptions) (string, error)
+ // Commit persists the pending changes to the database.
+ // If this Database is not bound to a batch, Commit() will fail with
+ // ErrNotBoundToBatch.
+ Commit(_ *context.T, _ rpc.ServerCall, schemaVersion int32) error
+ // Abort notifies the server that any pending changes can be discarded.
+ // It is not strictly required, but it may allow the server to release locks
+ // or other resources sooner than if it was not called.
+ // If this Database is not bound to a batch, Abort() will fail with
+ // ErrNotBoundToBatch.
+ Abort(_ *context.T, _ rpc.ServerCall, schemaVersion int32) error
+ // PauseSync pauses sync for this database. Incoming sync, as well as
+ // outgoing sync of subsequent writes, will be disabled until ResumeSync
+ // is called. PauseSync is idempotent.
+ PauseSync(*context.T, rpc.ServerCall) error
+ // ResumeSync resumes sync for this database. ResumeSync is idempotent.
+ ResumeSync(*context.T, rpc.ServerCall) error
+}
+
+// DatabaseServerStubMethods is the server interface containing
+// Database methods, as expected by rpc.Server.
+// The only difference between this interface and DatabaseServerMethods
+// is the streaming methods.
+type DatabaseServerStubMethods interface {
+ // Object provides access control for Vanadium objects.
+ //
+ // Vanadium services implementing dynamic access control would typically embed
+ // this interface and tag additional methods defined by the service with one of
+ // Admin, Read, Write, Resolve etc. For example, the VDL definition of the
+ // object would be:
+ //
+ // package mypackage
+ //
+ // import "v.io/v23/security/access"
+ // import "v.io/v23/services/permissions"
+ //
+ // type MyObject interface {
+ // permissions.Object
+ // MyRead() (string, error) {access.Read}
+ // MyWrite(string) error {access.Write}
+ // }
+ //
+ // If the set of pre-defined tags is insufficient, services may define their
+ // own tag type and annotate all methods with this new type.
+ //
+ // Instead of embedding this Object interface, define SetPermissions and
+ // GetPermissions in their own interface. Authorization policies will typically
+ // respect annotations of a single type. For example, the VDL definition of an
+ // object would be:
+ //
+ // package mypackage
+ //
+ // import "v.io/v23/security/access"
+ //
+ // type MyTag string
+ //
+ // const (
+ // Blue = MyTag("Blue")
+ // Red = MyTag("Red")
+ // )
+ //
+ // type MyObject interface {
+ // MyMethod() (string, error) {Blue}
+ //
+ // // Allow clients to change access via the access.Object interface:
+ // SetPermissions(perms access.Permissions, version string) error {Red}
+ // GetPermissions() (perms access.Permissions, version string, err error) {Blue}
+ // }
+ permissions.ObjectServerStubMethods
+ // DatabaseWatcher allows a client to watch for updates to the database. For
+ // each watch request, the client will receive a reliable stream of watch events
+ // without re-ordering. See watch.GlobWatcher for a detailed explanation of the
+ // behavior.
+ // TODO(rogulenko): Currently the only supported watch patterns are
+ // "<tableName>/<rowPrefix>*". Consider changing that.
+ //
+ // Watching is done by starting a streaming RPC. The RPC takes a ResumeMarker
+ // argument that points to a particular place in the database event log. If an
+ // empty ResumeMarker is provided, the WatchStream will begin with a Change
+ // batch containing the initial state. Otherwise, the WatchStream will contain
+ // only changes since the provided ResumeMarker.
+ //
+ // The result stream consists of a never-ending sequence of Change messages
+ // (until the call fails or is canceled). Each Change contains the Name field
+ // in the form "<tableName>/<rowKey>" and the Value field of the StoreChange
+ // type. If the client has no access to a row specified in a change, that change
+ // is excluded from the result stream.
+ //
+ // Note: A single Watch Change batch may contain changes from more than one
+ // batch as originally committed on a remote Syncbase or obtained from conflict
+ // resolution. However, changes from a single original batch will always appear
+ // in the same Change batch.
+ DatabaseWatcherServerStubMethods
+ // SyncgroupManager is the interface for syncgroup operations.
+ // TODO(hpucha): Add blessings to create/join and add a refresh method.
+ SyncgroupManagerServerStubMethods
+ // BlobManager is the interface for blob operations.
+ //
+ // Description of API for resumable blob creation (append-only):
+ // - Up until commit, a BlobRef may be used with PutBlob, GetBlobSize,
+ // DeleteBlob, and CommitBlob. Blob creation may be resumed by obtaining the
+ // current blob size via GetBlobSize and appending to the blob via PutBlob.
+ // - After commit, a blob is immutable, at which point PutBlob and CommitBlob
+ // may no longer be used.
+ // - All other methods (GetBlob, FetchBlob, PinBlob, etc.) may only be used
+ // after commit.
+ BlobManagerServerStubMethods
+ // SchemaManager implements the API for managing schema metadata attached
+ // to a Database.
+ SchemaManagerServerStubMethods
+ // ConflictManager interface provides all the methods necessary to handle
+ // conflict resolution for a given database.
+ ConflictManagerServerStubMethods
+ // Create creates this Database.
+ // If perms is nil, we inherit (copy) the App perms.
+ // Create requires the caller to have Write permission at the App.
+ Create(_ *context.T, _ rpc.ServerCall, metadata *SchemaMetadata, perms access.Permissions) error
+ // Destroy destroys this Database, permanently removing all of its data.
+ Destroy(_ *context.T, _ rpc.ServerCall, schemaVersion int32) error
+ // Exists returns true only if this Database exists. Insufficient permissions
+ // cause Exists to return false instead of an error.
+ // TODO(ivanpi): Exists may fail with an error if higher levels of hierarchy
+ // do not exist.
+ Exists(_ *context.T, _ rpc.ServerCall, schemaVersion int32) (bool, error)
+ // ListTables returns a list of all Table names.
+ // This method exists on Database but not on Service or App because for the
+ // latter we can simply use glob, while for the former glob fails on
+ // BatchDatabase since we encode the batch id in the BatchDatabase object
+ // name. More specifically, the glob client library appears to have two odd
+ // behaviors:
+ // 1) It checks Resolve access on every component along the path (by doing a
+ // Dispatcher.Lookup), whereas this doesn't happen for other RPCs.
+ // 2) It does a Glob(<prefix>/*) for every prefix path, and only proceeds to
+ // the next path component if that component appeared in its parent's Glob
+ // results. This is inefficient in general, and broken for us since
+ // Glob("app/*") does not return batch database names like "a/d##bId".
+ // TODO(sadovsky): Maybe switch to streaming RPC.
+ ListTables(*context.T, rpc.ServerCall) ([]string, error)
+ // Exec executes a syncQL query with positional parameters and returns all
+ // results as specified by the query's select/delete statement.
+ // Concurrency semantics are documented in model.go.
+ Exec(_ *context.T, _ *DatabaseExecServerCallStub, schemaVersion int32, query string, params []*vom.RawBytes) error
+ // BeginBatch creates a new batch. It returns a "batch suffix" string to
+ // append to the object name of this Database, yielding an object name for the
+ // Database bound to the created batch. (For example, if this Database is
+ // named "/path/to/db" and BeginBatch returns "##abc", the client should
+ // construct batch Database object name "/path/to/db##abc".) If this Database
+ // is already bound to a batch, BeginBatch() will fail with ErrBoundToBatch.
+ // Concurrency semantics are documented in model.go.
+ // TODO(sadovsky): Maybe make BatchOptions optional. Also, rename it to 'opts'
+ // everywhere now that v.io/i/912 is resolved.
+ BeginBatch(_ *context.T, _ rpc.ServerCall, schemaVersion int32, bo BatchOptions) (string, error)
+ // Commit persists the pending changes to the database.
+ // If this Database is not bound to a batch, Commit() will fail with
+ // ErrNotBoundToBatch.
+ Commit(_ *context.T, _ rpc.ServerCall, schemaVersion int32) error
+ // Abort notifies the server that any pending changes can be discarded.
+ // It is not strictly required, but it may allow the server to release locks
+ // or other resources sooner than if it was not called.
+ // If this Database is not bound to a batch, Abort() will fail with
+ // ErrNotBoundToBatch.
+ Abort(_ *context.T, _ rpc.ServerCall, schemaVersion int32) error
+ // PauseSync pauses sync for this database. Incoming sync, as well as
+ // outgoing sync of subsequent writes, will be disabled until ResumeSync
+ // is called. PauseSync is idempotent.
+ PauseSync(*context.T, rpc.ServerCall) error
+ // ResumeSync resumes sync for this database. ResumeSync is idempotent.
+ ResumeSync(*context.T, rpc.ServerCall) error
+}
+
+// DatabaseServerStub adds universal methods to DatabaseServerStubMethods.
+type DatabaseServerStub interface {
+ DatabaseServerStubMethods
+ // Describe the Database interfaces.
+ Describe__() []rpc.InterfaceDesc
+}
+
+// DatabaseServer returns a server stub for Database.
+// It converts an implementation of DatabaseServerMethods into
+// an object that may be used by rpc.Server.
+func DatabaseServer(impl DatabaseServerMethods) DatabaseServerStub {
+ stub := implDatabaseServerStub{
+ impl: impl,
+ ObjectServerStub: permissions.ObjectServer(impl),
+ DatabaseWatcherServerStub: DatabaseWatcherServer(impl),
+ SyncgroupManagerServerStub: SyncgroupManagerServer(impl),
+ BlobManagerServerStub: BlobManagerServer(impl),
+ SchemaManagerServerStub: SchemaManagerServer(impl),
+ ConflictManagerServerStub: ConflictManagerServer(impl),
+ }
+ // Initialize GlobState; always check the stub itself first, to handle the
+ // case where the user has the Glob method defined in their VDL source.
+ if gs := rpc.NewGlobState(stub); gs != nil {
+ stub.gs = gs
+ } else if gs := rpc.NewGlobState(impl); gs != nil {
+ stub.gs = gs
+ }
+ return stub
+}
+
+type implDatabaseServerStub struct {
+ impl DatabaseServerMethods
+ permissions.ObjectServerStub
+ DatabaseWatcherServerStub
+ SyncgroupManagerServerStub
+ BlobManagerServerStub
+ SchemaManagerServerStub
+ ConflictManagerServerStub
+ gs *rpc.GlobState
+}
+
+func (s implDatabaseServerStub) Create(ctx *context.T, call rpc.ServerCall, i0 *SchemaMetadata, i1 access.Permissions) error {
+ return s.impl.Create(ctx, call, i0, i1)
+}
+
+func (s implDatabaseServerStub) Destroy(ctx *context.T, call rpc.ServerCall, i0 int32) error {
+ return s.impl.Destroy(ctx, call, i0)
+}
+
+func (s implDatabaseServerStub) Exists(ctx *context.T, call rpc.ServerCall, i0 int32) (bool, error) {
+ return s.impl.Exists(ctx, call, i0)
+}
+
+func (s implDatabaseServerStub) ListTables(ctx *context.T, call rpc.ServerCall) ([]string, error) {
+ return s.impl.ListTables(ctx, call)
+}
+
+func (s implDatabaseServerStub) Exec(ctx *context.T, call *DatabaseExecServerCallStub, i0 int32, i1 string, i2 []*vom.RawBytes) error {
+ return s.impl.Exec(ctx, call, i0, i1, i2)
+}
+
+func (s implDatabaseServerStub) BeginBatch(ctx *context.T, call rpc.ServerCall, i0 int32, i1 BatchOptions) (string, error) {
+ return s.impl.BeginBatch(ctx, call, i0, i1)
+}
+
+func (s implDatabaseServerStub) Commit(ctx *context.T, call rpc.ServerCall, i0 int32) error {
+ return s.impl.Commit(ctx, call, i0)
+}
+
+func (s implDatabaseServerStub) Abort(ctx *context.T, call rpc.ServerCall, i0 int32) error {
+ return s.impl.Abort(ctx, call, i0)
+}
+
+func (s implDatabaseServerStub) PauseSync(ctx *context.T, call rpc.ServerCall) error {
+ return s.impl.PauseSync(ctx, call)
+}
+
+func (s implDatabaseServerStub) ResumeSync(ctx *context.T, call rpc.ServerCall) error {
+ return s.impl.ResumeSync(ctx, call)
+}
+
+func (s implDatabaseServerStub) Globber() *rpc.GlobState {
+ return s.gs
+}
+
+func (s implDatabaseServerStub) Describe__() []rpc.InterfaceDesc {
+ return []rpc.InterfaceDesc{DatabaseDesc, permissions.ObjectDesc, DatabaseWatcherDesc, watch.GlobWatcherDesc, SyncgroupManagerDesc, BlobManagerDesc, SchemaManagerDesc, ConflictManagerDesc}
+}
+
+// DatabaseDesc describes the Database interface.
+var DatabaseDesc rpc.InterfaceDesc = descDatabase
+
+// descDatabase hides the desc to keep godoc clean.
+var descDatabase = rpc.InterfaceDesc{
+ Name: "Database",
+ PkgPath: "v.io/v23/services/syncbase/nosql",
+ Doc: "// Database represents a collection of Tables. Batches, queries, sync, watch,\n// etc. all operate at the Database level.\n// Database.Glob operates over Table names.\n// Param schemaVersion is the version number that the client expects the\n// database to be at. To disable schema version checking, pass -1.",
+ Embeds: []rpc.EmbedDesc{
+ {"Object", "v.io/v23/services/permissions", "// Object provides access control for Vanadium objects.\n//\n// Vanadium services implementing dynamic access control would typically embed\n// this interface and tag additional methods defined by the service with one of\n// Admin, Read, Write, Resolve etc. For example, the VDL definition of the\n// object would be:\n//\n// package mypackage\n//\n// import \"v.io/v23/security/access\"\n// import \"v.io/v23/services/permissions\"\n//\n// type MyObject interface {\n// permissions.Object\n// MyRead() (string, error) {access.Read}\n// MyWrite(string) error {access.Write}\n// }\n//\n// If the set of pre-defined tags is insufficient, services may define their\n// own tag type and annotate all methods with this new type.\n//\n// Instead of embedding this Object interface, define SetPermissions and\n// GetPermissions in their own interface. Authorization policies will typically\n// respect annotations of a single type. For example, the VDL definition of an\n// object would be:\n//\n// package mypackage\n//\n// import \"v.io/v23/security/access\"\n//\n// type MyTag string\n//\n// const (\n// Blue = MyTag(\"Blue\")\n// Red = MyTag(\"Red\")\n// )\n//\n// type MyObject interface {\n// MyMethod() (string, error) {Blue}\n//\n// // Allow clients to change access via the access.Object interface:\n// SetPermissions(perms access.Permissions, version string) error {Red}\n// GetPermissions() (perms access.Permissions, version string, err error) {Blue}\n// }"},
+ {"DatabaseWatcher", "v.io/v23/services/syncbase/nosql", "// DatabaseWatcher allows a client to watch for updates to the database. For\n// each watch request, the client will receive a reliable stream of watch events\n// without re-ordering. See watch.GlobWatcher for a detailed explanation of the\n// behavior.\n// TODO(rogulenko): Currently the only supported watch patterns are\n// \"<tableName>/<rowPrefix>*\". Consider changing that.\n//\n// Watching is done by starting a streaming RPC. The RPC takes a ResumeMarker\n// argument that points to a particular place in the database event log. If an\n// empty ResumeMarker is provided, the WatchStream will begin with a Change\n// batch containing the initial state. Otherwise, the WatchStream will contain\n// only changes since the provided ResumeMarker.\n//\n// The result stream consists of a never-ending sequence of Change messages\n// (until the call fails or is canceled). Each Change contains the Name field\n// in the form \"<tableName>/<rowKey>\" and the Value field of the StoreChange\n// type. If the client has no access to a row specified in a change, that change\n// is excluded from the result stream.\n//\n// Note: A single Watch Change batch may contain changes from more than one\n// batch as originally committed on a remote Syncbase or obtained from conflict\n// resolution. However, changes from a single original batch will always appear\n// in the same Change batch."},
+ {"SyncgroupManager", "v.io/v23/services/syncbase/nosql", "// SyncgroupManager is the interface for syncgroup operations.\n// TODO(hpucha): Add blessings to create/join and add a refresh method."},
+ {"BlobManager", "v.io/v23/services/syncbase/nosql", "// BlobManager is the interface for blob operations.\n//\n// Description of API for resumable blob creation (append-only):\n// - Up until commit, a BlobRef may be used with PutBlob, GetBlobSize,\n// DeleteBlob, and CommitBlob. Blob creation may be resumed by obtaining the\n// current blob size via GetBlobSize and appending to the blob via PutBlob.\n// - After commit, a blob is immutable, at which point PutBlob and CommitBlob\n// may no longer be used.\n// - All other methods (GetBlob, FetchBlob, PinBlob, etc.) may only be used\n// after commit."},
+ {"SchemaManager", "v.io/v23/services/syncbase/nosql", "// SchemaManager implements the API for managing schema metadata attached\n// to a Database."},
+ {"ConflictManager", "v.io/v23/services/syncbase/nosql", "// ConflictManager interface provides all the methods necessary to handle\n// conflict resolution for a given database."},
+ },
+ Methods: []rpc.MethodDesc{
+ {
+ Name: "Create",
+ Doc: "// Create creates this Database.\n// If perms is nil, we inherit (copy) the App perms.\n// Create requires the caller to have Write permission at the App.",
+ InArgs: []rpc.ArgDesc{
+ {"metadata", ``}, // *SchemaMetadata
+ {"perms", ``}, // access.Permissions
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "Destroy",
+ Doc: "// Destroy destroys this Database, permanently removing all of its data.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "Exists",
+ Doc: "// Exists returns true only if this Database exists. Insufficient permissions\n// cause Exists to return false instead of an error.\n// TODO(ivanpi): Exists may fail with an error if higher levels of hierarchy\n// do not exist.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ },
+ OutArgs: []rpc.ArgDesc{
+ {"", ``}, // bool
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Resolve"))},
+ },
+ {
+ Name: "ListTables",
+ Doc: "// ListTables returns a list of all Table names.\n// This method exists on Database but not on Service or App because for the\n// latter we can simply use glob, while for the former glob fails on\n// BatchDatabase since we encode the batch id in the BatchDatabase object\n// name. More specifically, the glob client library appears to have two odd\n// behaviors:\n// 1) It checks Resolve access on every component along the path (by doing a\n// Dispatcher.Lookup), whereas this doesn't happen for other RPCs.\n// 2) It does a Glob(<prefix>/*) for every prefix path, and only proceeds to\n// the next path component if that component appeared in its parent's Glob\n// results. This is inefficient in general, and broken for us since\n// Glob(\"app/*\") does not return batch database names like \"a/d##bId\".\n// TODO(sadovsky): Maybe switch to streaming RPC.",
+ OutArgs: []rpc.ArgDesc{
+ {"", ``}, // []string
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "Exec",
+ Doc: "// Exec executes a syncQL query with positional parameters and returns all\n// results as specified by the query's select/delete statement.\n// Concurrency semantics are documented in model.go.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ {"query", ``}, // string
+ {"params", ``}, // []*vom.RawBytes
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "BeginBatch",
+ Doc: "// BeginBatch creates a new batch. It returns a \"batch suffix\" string to\n// append to the object name of this Database, yielding an object name for the\n// Database bound to the created batch. (For example, if this Database is\n// named \"/path/to/db\" and BeginBatch returns \"##abc\", the client should\n// construct batch Database object name \"/path/to/db##abc\".) If this Database\n// is already bound to a batch, BeginBatch() will fail with ErrBoundToBatch.\n// Concurrency semantics are documented in model.go.\n// TODO(sadovsky): Maybe make BatchOptions optional. Also, rename it to 'opts'\n// everywhere now that v.io/i/912 is resolved.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ {"bo", ``}, // BatchOptions
+ },
+ OutArgs: []rpc.ArgDesc{
+ {"", ``}, // string
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "Commit",
+ Doc: "// Commit persists the pending changes to the database.\n// If this Database is not bound to a batch, Commit() will fail with\n// ErrNotBoundToBatch.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "Abort",
+ Doc: "// Abort notifies the server that any pending changes can be discarded.\n// It is not strictly required, but it may allow the server to release locks\n// or other resources sooner than if it was not called.\n// If this Database is not bound to a batch, Abort() will fail with\n// ErrNotBoundToBatch.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "PauseSync",
+ Doc: "// PauseSync pauses sync for this database. Incoming sync, as well as\n// outgoing sync of subsequent writes, will be disabled until ResumeSync\n// is called. PauseSync is idempotent.",
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "ResumeSync",
+ Doc: "// ResumeSync resumes sync for this database. ResumeSync is idempotent.",
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ },
+}
+
+// DatabaseExecServerStream is the server stream for Database.Exec.
+type DatabaseExecServerStream interface {
+ // SendStream returns the send side of the Database.Exec server stream.
+ SendStream() interface {
+ // Send places the item onto the output stream. Returns errors encountered
+ // while sending. Blocks if there is no buffer space; will unblock when
+ // buffer space is available.
+ Send(item []*vom.RawBytes) error
+ }
+}
+
+// DatabaseExecServerCall represents the context passed to Database.Exec.
+type DatabaseExecServerCall interface {
+ rpc.ServerCall
+ DatabaseExecServerStream
+}
+
+// DatabaseExecServerCallStub is a wrapper that converts rpc.StreamServerCall into
+// a typesafe stub that implements DatabaseExecServerCall.
+type DatabaseExecServerCallStub struct {
+ rpc.StreamServerCall
+}
+
+// Init initializes DatabaseExecServerCallStub from rpc.StreamServerCall.
+func (s *DatabaseExecServerCallStub) Init(call rpc.StreamServerCall) {
+ s.StreamServerCall = call
+}
+
+// SendStream returns the send side of the Database.Exec server stream.
+func (s *DatabaseExecServerCallStub) SendStream() interface {
+ Send(item []*vom.RawBytes) error
+} {
+ return implDatabaseExecServerCallSend{s}
+}
+
+type implDatabaseExecServerCallSend struct {
+ s *DatabaseExecServerCallStub
+}
+
+func (s implDatabaseExecServerCallSend) Send(item []*vom.RawBytes) error {
+ return s.s.Send(item)
+}
+
+// TableClientMethods is the client interface
+// containing Table methods.
+//
+// Table represents a collection of Rows.
+// Table.Glob operates over the primary keys of Rows in the Table.
+// SchemaVersion is the version number that the client expects the database
+// to be at. To disable schema version checking, pass -1.
+type TableClientMethods interface {
+ // Create creates this Table.
+ // If perms is nil, we inherit (copy) the Database perms.
+ Create(_ *context.T, schemaVersion int32, perms access.Permissions, _ ...rpc.CallOpt) error
+ // Destroy destroys this Table.
+ Destroy(_ *context.T, schemaVersion int32, _ ...rpc.CallOpt) error
+ // Exists returns true only if this Table exists. Insufficient permissions
+ // cause Exists to return false instead of an error.
+ // TODO(ivanpi): Exists may fail with an error if higher levels of hierarchy
+ // do not exist.
+ Exists(_ *context.T, schemaVersion int32, _ ...rpc.CallOpt) (bool, error)
+ // GetPermissions returns the current Permissions for the Table.
+ GetPermissions(_ *context.T, schemaVersion int32, _ ...rpc.CallOpt) (access.Permissions, error)
+ // SetPermissions replaces the current Permissions for the Table.
+ SetPermissions(_ *context.T, schemaVersion int32, perms access.Permissions, _ ...rpc.CallOpt) error
+ // DeleteRange deletes all rows in the given half-open range [start, limit).
+ // If limit is "", all rows with keys >= start are included.
+ // TODO(sadovsky): Maybe add option to delete prefix perms fully covered by
+ // the row range.
+ DeleteRange(_ *context.T, schemaVersion int32, start []byte, limit []byte, _ ...rpc.CallOpt) error
+ // Scan returns all rows in the given half-open range [start, limit). If limit
+ // is "", all rows with keys >= start are included. Concurrency semantics are
+ // documented in model.go.
+ Scan(_ *context.T, schemaVersion int32, start []byte, limit []byte, _ ...rpc.CallOpt) (TableScanClientCall, error)
+ // GetPrefixPermissions returns an array of (prefix, perms) pairs. The array is
+ // sorted from longest prefix to shortest, so element zero is the one that
+ // applies to the row with the given key. The last element is always the
+ // prefix "" which represents the table's permissions -- the array will always
+ // have at least one element.
+ GetPrefixPermissions(_ *context.T, schemaVersion int32, key string, _ ...rpc.CallOpt) ([]PrefixPermissions, error)
+ // SetPrefixPermissions sets the permissions for all current and future rows with
+ // the given prefix. If the prefix overlaps with an existing prefix, the
+ // longest prefix that matches a row applies. For example:
+ // SetPrefixPermissions(ctx, Prefix("a/b"), perms1)
+ // SetPrefixPermissions(ctx, Prefix("a/b/c"), perms2)
+ // The permissions for row "a/b/1" are perms1, and the permissions for row
+ // "a/b/c/1" are perms2.
+ SetPrefixPermissions(_ *context.T, schemaVersion int32, prefix string, perms access.Permissions, _ ...rpc.CallOpt) error
+ // DeletePrefixPermissions deletes the permissions for the specified prefix. Any
+ // rows covered by this prefix will use the next longest prefix's permissions
+ // (see the array returned by GetPrefixPermissions).
+ DeletePrefixPermissions(_ *context.T, schemaVersion int32, prefix string, _ ...rpc.CallOpt) error
+}
+
+// TableClientStub adds universal methods to TableClientMethods.
+type TableClientStub interface {
+ TableClientMethods
+ rpc.UniversalServiceMethods
+}
+
+// TableClient returns a client stub for Table.
+func TableClient(name string) TableClientStub {
+ return implTableClientStub{name}
+}
+
+type implTableClientStub struct {
+ name string
+}
+
+func (c implTableClientStub) Create(ctx *context.T, i0 int32, i1 access.Permissions, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "Create", []interface{}{i0, i1}, nil, opts...)
+ return
+}
+
+func (c implTableClientStub) Destroy(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "Destroy", []interface{}{i0}, nil, opts...)
+ return
+}
+
+func (c implTableClientStub) Exists(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (o0 bool, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "Exists", []interface{}{i0}, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implTableClientStub) GetPermissions(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (o0 access.Permissions, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "GetPermissions", []interface{}{i0}, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implTableClientStub) SetPermissions(ctx *context.T, i0 int32, i1 access.Permissions, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "SetPermissions", []interface{}{i0, i1}, nil, opts...)
+ return
+}
+
+func (c implTableClientStub) DeleteRange(ctx *context.T, i0 int32, i1 []byte, i2 []byte, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "DeleteRange", []interface{}{i0, i1, i2}, nil, opts...)
+ return
+}
+
+func (c implTableClientStub) Scan(ctx *context.T, i0 int32, i1 []byte, i2 []byte, opts ...rpc.CallOpt) (ocall TableScanClientCall, err error) {
+ var call rpc.ClientCall
+ if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "Scan", []interface{}{i0, i1, i2}, opts...); err != nil {
+ return
+ }
+ ocall = &implTableScanClientCall{ClientCall: call}
+ return
+}
+
+func (c implTableClientStub) GetPrefixPermissions(ctx *context.T, i0 int32, i1 string, opts ...rpc.CallOpt) (o0 []PrefixPermissions, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "GetPrefixPermissions", []interface{}{i0, i1}, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implTableClientStub) SetPrefixPermissions(ctx *context.T, i0 int32, i1 string, i2 access.Permissions, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "SetPrefixPermissions", []interface{}{i0, i1, i2}, nil, opts...)
+ return
+}
+
+func (c implTableClientStub) DeletePrefixPermissions(ctx *context.T, i0 int32, i1 string, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "DeletePrefixPermissions", []interface{}{i0, i1}, nil, opts...)
+ return
+}
+
+// TableScanClientStream is the client stream for Table.Scan.
+type TableScanClientStream interface {
+ // RecvStream returns the receiver side of the Table.Scan client stream.
+ RecvStream() interface {
+ // Advance stages an item so that it may be retrieved via Value. Returns
+ // true iff there is an item to retrieve. Advance must be called before
+ // Value is called. May block if an item is not available.
+ Advance() bool
+ // Value returns the item that was staged by Advance. May panic if Advance
+ // returned false or was not called. Never blocks.
+ Value() KeyValue
+ // Err returns any error encountered by Advance. Never blocks.
+ Err() error
+ }
+}
+
+// TableScanClientCall represents the call returned from Table.Scan.
+type TableScanClientCall interface {
+ TableScanClientStream
+ // Finish blocks until the server is done, and returns the positional return
+ // values for call.
+ //
+ // Finish returns immediately if the call has been canceled; depending on the
+ // timing the output could either be an error signaling cancelation, or the
+ // valid positional return values from the server.
+ //
+ // Calling Finish is mandatory for releasing stream resources, unless the call
+ // has been canceled or any of the other methods return an error. Finish should
+ // be called at most once.
+ Finish() error
+}
+
+type implTableScanClientCall struct {
+ rpc.ClientCall
+ valRecv KeyValue
+ errRecv error
+}
+
+func (c *implTableScanClientCall) RecvStream() interface {
+ Advance() bool
+ Value() KeyValue
+ Err() error
+} {
+ return implTableScanClientCallRecv{c}
+}
+
+type implTableScanClientCallRecv struct {
+ c *implTableScanClientCall
+}
+
+func (c implTableScanClientCallRecv) Advance() bool {
+ c.c.valRecv = KeyValue{}
+ c.c.errRecv = c.c.Recv(&c.c.valRecv)
+ return c.c.errRecv == nil
+}
+func (c implTableScanClientCallRecv) Value() KeyValue {
+ return c.c.valRecv
+}
+func (c implTableScanClientCallRecv) Err() error {
+ if c.c.errRecv == io.EOF {
+ return nil
+ }
+ return c.c.errRecv
+}
+func (c *implTableScanClientCall) Finish() (err error) {
+ err = c.ClientCall.Finish()
+ return
+}
+
+// TableServerMethods is the interface a server writer
+// implements for Table.
+//
+// Table represents a collection of Rows.
+// Table.Glob operates over the primary keys of Rows in the Table.
+// SchemaVersion is the version number that the client expects the database
+// to be at. To disable schema version checking, pass -1.
+type TableServerMethods interface {
+ // Create creates this Table.
+ // If perms is nil, we inherit (copy) the Database perms.
+ Create(_ *context.T, _ rpc.ServerCall, schemaVersion int32, perms access.Permissions) error
+ // Destroy destroys this Table.
+ Destroy(_ *context.T, _ rpc.ServerCall, schemaVersion int32) error
+ // Exists returns true only if this Table exists. Insufficient permissions
+ // cause Exists to return false instead of an error.
+ // TODO(ivanpi): Exists may fail with an error if higher levels of hierarchy
+ // do not exist.
+ Exists(_ *context.T, _ rpc.ServerCall, schemaVersion int32) (bool, error)
+ // GetPermissions returns the current Permissions for the Table.
+ GetPermissions(_ *context.T, _ rpc.ServerCall, schemaVersion int32) (access.Permissions, error)
+ // SetPermissions replaces the current Permissions for the Table.
+ SetPermissions(_ *context.T, _ rpc.ServerCall, schemaVersion int32, perms access.Permissions) error
+ // DeleteRange deletes all rows in the given half-open range [start, limit).
+ // If limit is "", all rows with keys >= start are included.
+ // TODO(sadovsky): Maybe add option to delete prefix perms fully covered by
+ // the row range.
+ DeleteRange(_ *context.T, _ rpc.ServerCall, schemaVersion int32, start []byte, limit []byte) error
+ // Scan returns all rows in the given half-open range [start, limit). If limit
+ // is "", all rows with keys >= start are included. Concurrency semantics are
+ // documented in model.go.
+ Scan(_ *context.T, _ TableScanServerCall, schemaVersion int32, start []byte, limit []byte) error
+ // GetPrefixPermissions returns an array of (prefix, perms) pairs. The array is
+ // sorted from longest prefix to shortest, so element zero is the one that
+ // applies to the row with the given key. The last element is always the
+ // prefix "" which represents the table's permissions -- the array will always
+ // have at least one element.
+ GetPrefixPermissions(_ *context.T, _ rpc.ServerCall, schemaVersion int32, key string) ([]PrefixPermissions, error)
+ // SetPrefixPermissions sets the permissions for all current and future rows with
+ // the given prefix. If the prefix overlaps with an existing prefix, the
+ // longest prefix that matches a row applies. For example:
+ // SetPrefixPermissions(ctx, Prefix("a/b"), perms1)
+ // SetPrefixPermissions(ctx, Prefix("a/b/c"), perms2)
+ // The permissions for row "a/b/1" are perms1, and the permissions for row
+ // "a/b/c/1" are perms2.
+ SetPrefixPermissions(_ *context.T, _ rpc.ServerCall, schemaVersion int32, prefix string, perms access.Permissions) error
+ // DeletePrefixPermissions deletes the permissions for the specified prefix. Any
+ // rows covered by this prefix will use the next longest prefix's permissions
+ // (see the array returned by GetPrefixPermissions).
+ DeletePrefixPermissions(_ *context.T, _ rpc.ServerCall, schemaVersion int32, prefix string) error
+}
+
+// TableServerStubMethods is the server interface containing
+// Table methods, as expected by rpc.Server.
+// The only difference between this interface and TableServerMethods
+// is the streaming methods.
+type TableServerStubMethods interface {
+ // Create creates this Table.
+ // If perms is nil, we inherit (copy) the Database perms.
+ Create(_ *context.T, _ rpc.ServerCall, schemaVersion int32, perms access.Permissions) error
+ // Destroy destroys this Table.
+ Destroy(_ *context.T, _ rpc.ServerCall, schemaVersion int32) error
+ // Exists returns true only if this Table exists. Insufficient permissions
+ // cause Exists to return false instead of an error.
+ // TODO(ivanpi): Exists may fail with an error if higher levels of hierarchy
+ // do not exist.
+ Exists(_ *context.T, _ rpc.ServerCall, schemaVersion int32) (bool, error)
+ // GetPermissions returns the current Permissions for the Table.
+ GetPermissions(_ *context.T, _ rpc.ServerCall, schemaVersion int32) (access.Permissions, error)
+ // SetPermissions replaces the current Permissions for the Table.
+ SetPermissions(_ *context.T, _ rpc.ServerCall, schemaVersion int32, perms access.Permissions) error
+ // DeleteRange deletes all rows in the given half-open range [start, limit).
+ // If limit is "", all rows with keys >= start are included.
+ // TODO(sadovsky): Maybe add option to delete prefix perms fully covered by
+ // the row range.
+ DeleteRange(_ *context.T, _ rpc.ServerCall, schemaVersion int32, start []byte, limit []byte) error
+ // Scan returns all rows in the given half-open range [start, limit). If limit
+ // is "", all rows with keys >= start are included. Concurrency semantics are
+ // documented in model.go.
+ Scan(_ *context.T, _ *TableScanServerCallStub, schemaVersion int32, start []byte, limit []byte) error
+ // GetPrefixPermissions returns an array of (prefix, perms) pairs. The array is
+ // sorted from longest prefix to shortest, so element zero is the one that
+ // applies to the row with the given key. The last element is always the
+ // prefix "" which represents the table's permissions -- the array will always
+ // have at least one element.
+ GetPrefixPermissions(_ *context.T, _ rpc.ServerCall, schemaVersion int32, key string) ([]PrefixPermissions, error)
+ // SetPrefixPermissions sets the permissions for all current and future rows with
+ // the given prefix. If the prefix overlaps with an existing prefix, the
+ // longest prefix that matches a row applies. For example:
+ // SetPrefixPermissions(ctx, Prefix("a/b"), perms1)
+ // SetPrefixPermissions(ctx, Prefix("a/b/c"), perms2)
+ // The permissions for row "a/b/1" are perms1, and the permissions for row
+ // "a/b/c/1" are perms2.
+ SetPrefixPermissions(_ *context.T, _ rpc.ServerCall, schemaVersion int32, prefix string, perms access.Permissions) error
+ // DeletePrefixPermissions deletes the permissions for the specified prefix. Any
+ // rows covered by this prefix will use the next longest prefix's permissions
+ // (see the array returned by GetPrefixPermissions).
+ DeletePrefixPermissions(_ *context.T, _ rpc.ServerCall, schemaVersion int32, prefix string) error
+}
+
+// TableServerStub adds universal methods to TableServerStubMethods.
+type TableServerStub interface {
+ TableServerStubMethods
+ // Describe the Table interfaces.
+ Describe__() []rpc.InterfaceDesc
+}
+
+// TableServer returns a server stub for Table.
+// It converts an implementation of TableServerMethods into
+// an object that may be used by rpc.Server.
+func TableServer(impl TableServerMethods) TableServerStub {
+ stub := implTableServerStub{
+ impl: impl,
+ }
+ // Initialize GlobState; always check the stub itself first, to handle the
+ // case where the user has the Glob method defined in their VDL source.
+ if gs := rpc.NewGlobState(stub); gs != nil {
+ stub.gs = gs
+ } else if gs := rpc.NewGlobState(impl); gs != nil {
+ stub.gs = gs
+ }
+ return stub
+}
+
+type implTableServerStub struct {
+ impl TableServerMethods
+ gs *rpc.GlobState
+}
+
+func (s implTableServerStub) Create(ctx *context.T, call rpc.ServerCall, i0 int32, i1 access.Permissions) error {
+ return s.impl.Create(ctx, call, i0, i1)
+}
+
+func (s implTableServerStub) Destroy(ctx *context.T, call rpc.ServerCall, i0 int32) error {
+ return s.impl.Destroy(ctx, call, i0)
+}
+
+func (s implTableServerStub) Exists(ctx *context.T, call rpc.ServerCall, i0 int32) (bool, error) {
+ return s.impl.Exists(ctx, call, i0)
+}
+
+func (s implTableServerStub) GetPermissions(ctx *context.T, call rpc.ServerCall, i0 int32) (access.Permissions, error) {
+ return s.impl.GetPermissions(ctx, call, i0)
+}
+
+func (s implTableServerStub) SetPermissions(ctx *context.T, call rpc.ServerCall, i0 int32, i1 access.Permissions) error {
+ return s.impl.SetPermissions(ctx, call, i0, i1)
+}
+
+func (s implTableServerStub) DeleteRange(ctx *context.T, call rpc.ServerCall, i0 int32, i1 []byte, i2 []byte) error {
+ return s.impl.DeleteRange(ctx, call, i0, i1, i2)
+}
+
+func (s implTableServerStub) Scan(ctx *context.T, call *TableScanServerCallStub, i0 int32, i1 []byte, i2 []byte) error {
+ return s.impl.Scan(ctx, call, i0, i1, i2)
+}
+
+func (s implTableServerStub) GetPrefixPermissions(ctx *context.T, call rpc.ServerCall, i0 int32, i1 string) ([]PrefixPermissions, error) {
+ return s.impl.GetPrefixPermissions(ctx, call, i0, i1)
+}
+
+func (s implTableServerStub) SetPrefixPermissions(ctx *context.T, call rpc.ServerCall, i0 int32, i1 string, i2 access.Permissions) error {
+ return s.impl.SetPrefixPermissions(ctx, call, i0, i1, i2)
+}
+
+func (s implTableServerStub) DeletePrefixPermissions(ctx *context.T, call rpc.ServerCall, i0 int32, i1 string) error {
+ return s.impl.DeletePrefixPermissions(ctx, call, i0, i1)
+}
+
+func (s implTableServerStub) Globber() *rpc.GlobState {
+ return s.gs
+}
+
+func (s implTableServerStub) Describe__() []rpc.InterfaceDesc {
+ return []rpc.InterfaceDesc{TableDesc}
+}
+
+// TableDesc describes the Table interface.
+var TableDesc rpc.InterfaceDesc = descTable
+
+// descTable hides the desc to keep godoc clean.
+var descTable = rpc.InterfaceDesc{
+ Name: "Table",
+ PkgPath: "v.io/v23/services/syncbase/nosql",
+ Doc: "// Table represents a collection of Rows.\n// Table.Glob operates over the primary keys of Rows in the Table.\n// SchemaVersion is the version number that the client expects the database\n// to be at. To disable schema version checking, pass -1.",
+ Methods: []rpc.MethodDesc{
+ {
+ Name: "Create",
+ Doc: "// Create creates this Table.\n// If perms is nil, we inherit (copy) the Database perms.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ {"perms", ``}, // access.Permissions
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "Destroy",
+ Doc: "// Destroy destroys this Table.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "Exists",
+ Doc: "// Exists returns true only if this Table exists. Insufficient permissions\n// cause Exists to return false instead of an error.\n// TODO(ivanpi): Exists may fail with an error if higher levels of hierarchy\n// do not exist.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ },
+ OutArgs: []rpc.ArgDesc{
+ {"", ``}, // bool
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Resolve"))},
+ },
+ {
+ Name: "GetPermissions",
+ Doc: "// GetPermissions returns the current Permissions for the Table.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ },
+ OutArgs: []rpc.ArgDesc{
+ {"", ``}, // access.Permissions
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Admin"))},
+ },
+ {
+ Name: "SetPermissions",
+ Doc: "// SetPermissions replaces the current Permissions for the Table.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ {"perms", ``}, // access.Permissions
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Admin"))},
+ },
+ {
+ Name: "DeleteRange",
+ Doc: "// DeleteRange deletes all rows in the given half-open range [start, limit).\n// If limit is \"\", all rows with keys >= start are included.\n// TODO(sadovsky): Maybe add option to delete prefix perms fully covered by\n// the row range.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ {"start", ``}, // []byte
+ {"limit", ``}, // []byte
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "Scan",
+ Doc: "// Scan returns all rows in the given half-open range [start, limit). If limit\n// is \"\", all rows with keys >= start are included. Concurrency semantics are\n// documented in model.go.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ {"start", ``}, // []byte
+ {"limit", ``}, // []byte
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "GetPrefixPermissions",
+ Doc: "// GetPrefixPermissions returns an array of (prefix, perms) pairs. The array is\n// sorted from longest prefix to shortest, so element zero is the one that\n// applies to the row with the given key. The last element is always the\n// prefix \"\" which represents the table's permissions -- the array will always\n// have at least one element.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ {"key", ``}, // string
+ },
+ OutArgs: []rpc.ArgDesc{
+ {"", ``}, // []PrefixPermissions
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Admin"))},
+ },
+ {
+ Name: "SetPrefixPermissions",
+ Doc: "// SetPrefixPermissions sets the permissions for all current and future rows with\n// the given prefix. If the prefix overlaps with an existing prefix, the\n// longest prefix that matches a row applies. For example:\n// SetPrefixPermissions(ctx, Prefix(\"a/b\"), perms1)\n// SetPrefixPermissions(ctx, Prefix(\"a/b/c\"), perms2)\n// The permissions for row \"a/b/1\" are perms1, and the permissions for row\n// \"a/b/c/1\" are perms2.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ {"prefix", ``}, // string
+ {"perms", ``}, // access.Permissions
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Admin"))},
+ },
+ {
+ Name: "DeletePrefixPermissions",
+ Doc: "// DeletePrefixPermissions deletes the permissions for the specified prefix. Any\n// rows covered by this prefix will use the next longest prefix's permissions\n// (see the array returned by GetPrefixPermissions).",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ {"prefix", ``}, // string
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Admin"))},
+ },
+ },
+}
+
+// TableScanServerStream is the server stream for Table.Scan.
+type TableScanServerStream interface {
+ // SendStream returns the send side of the Table.Scan server stream.
+ SendStream() interface {
+ // Send places the item onto the output stream. Returns errors encountered
+ // while sending. Blocks if there is no buffer space; will unblock when
+ // buffer space is available.
+ Send(item KeyValue) error
+ }
+}
+
+// TableScanServerCall represents the context passed to Table.Scan.
+type TableScanServerCall interface {
+ rpc.ServerCall
+ TableScanServerStream
+}
+
+// TableScanServerCallStub is a wrapper that converts rpc.StreamServerCall into
+// a typesafe stub that implements TableScanServerCall.
+type TableScanServerCallStub struct {
+ rpc.StreamServerCall
+}
+
+// Init initializes TableScanServerCallStub from rpc.StreamServerCall.
+func (s *TableScanServerCallStub) Init(call rpc.StreamServerCall) {
+ s.StreamServerCall = call
+}
+
+// SendStream returns the send side of the Table.Scan server stream.
+func (s *TableScanServerCallStub) SendStream() interface {
+ Send(item KeyValue) error
+} {
+ return implTableScanServerCallSend{s}
+}
+
+type implTableScanServerCallSend struct {
+ s *TableScanServerCallStub
+}
+
+func (s implTableScanServerCallSend) Send(item KeyValue) error {
+ return s.s.Send(item)
+}
+
+// RowClientMethods is the client interface
+// containing Row methods.
+//
+// Row represents a single row in a Table.
+// All access checks are performed against the most specific matching prefix
+// permissions in the Table.
+// SchemaVersion is the version number that the client expects the database
+// to be at. To disable schema version checking, pass -1.
+// NOTE(sadovsky): Currently we send []byte values over the wire for Get, Put,
+// and Scan. If there's a way to avoid encoding/decoding on the server side, we
+// can use vdl.Value everywhere without sacrificing performance.
+type RowClientMethods interface {
+ // Exists returns true only if this Row exists. Insufficient permissions
+ // cause Exists to return false instead of an error.
+ // Note, Exists on Row requires read permissions, unlike higher levels of
+ // hierarchy which require resolve, because Row existence usually carries
+ // more information.
+ // TODO(ivanpi): Exists may fail with an error if higher levels of hierarchy
+ // do not exist.
+ Exists(_ *context.T, schemaVersion int32, _ ...rpc.CallOpt) (bool, error)
+ // Get returns the value for this Row.
+ Get(_ *context.T, schemaVersion int32, _ ...rpc.CallOpt) ([]byte, error)
+ // Put writes the given value for this Row.
+ Put(_ *context.T, schemaVersion int32, value []byte, _ ...rpc.CallOpt) error
+ // Delete deletes this Row.
+ Delete(_ *context.T, schemaVersion int32, _ ...rpc.CallOpt) error
+}
+
+// RowClientStub adds universal methods to RowClientMethods.
+type RowClientStub interface {
+ RowClientMethods
+ rpc.UniversalServiceMethods
+}
+
+// RowClient returns a client stub for Row.
+func RowClient(name string) RowClientStub {
+ return implRowClientStub{name}
+}
+
+type implRowClientStub struct {
+ name string
+}
+
+func (c implRowClientStub) Exists(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (o0 bool, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "Exists", []interface{}{i0}, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implRowClientStub) Get(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (o0 []byte, err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "Get", []interface{}{i0}, []interface{}{&o0}, opts...)
+ return
+}
+
+func (c implRowClientStub) Put(ctx *context.T, i0 int32, i1 []byte, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "Put", []interface{}{i0, i1}, nil, opts...)
+ return
+}
+
+func (c implRowClientStub) Delete(ctx *context.T, i0 int32, opts ...rpc.CallOpt) (err error) {
+ err = v23.GetClient(ctx).Call(ctx, c.name, "Delete", []interface{}{i0}, nil, opts...)
+ return
+}
+
+// RowServerMethods is the interface a server writer
+// implements for Row.
+//
+// Row represents a single row in a Table.
+// All access checks are performed against the most specific matching prefix
+// permissions in the Table.
+// SchemaVersion is the version number that the client expects the database
+// to be at. To disable schema version checking, pass -1.
+// NOTE(sadovsky): Currently we send []byte values over the wire for Get, Put,
+// and Scan. If there's a way to avoid encoding/decoding on the server side, we
+// can use vdl.Value everywhere without sacrificing performance.
+type RowServerMethods interface {
+ // Exists returns true only if this Row exists. Insufficient permissions
+ // cause Exists to return false instead of an error.
+ // Note, Exists on Row requires read permissions, unlike higher levels of
+ // hierarchy which require resolve, because Row existence usually carries
+ // more information.
+ // TODO(ivanpi): Exists may fail with an error if higher levels of hierarchy
+ // do not exist.
+ Exists(_ *context.T, _ rpc.ServerCall, schemaVersion int32) (bool, error)
+ // Get returns the value for this Row.
+ Get(_ *context.T, _ rpc.ServerCall, schemaVersion int32) ([]byte, error)
+ // Put writes the given value for this Row.
+ Put(_ *context.T, _ rpc.ServerCall, schemaVersion int32, value []byte) error
+ // Delete deletes this Row.
+ Delete(_ *context.T, _ rpc.ServerCall, schemaVersion int32) error
+}
+
+// RowServerStubMethods is the server interface containing
+// Row methods, as expected by rpc.Server.
+// There is no difference between this interface and RowServerMethods
+// since there are no streaming methods.
+type RowServerStubMethods RowServerMethods
+
+// RowServerStub adds universal methods to RowServerStubMethods.
+type RowServerStub interface {
+ RowServerStubMethods
+ // Describe the Row interfaces.
+ Describe__() []rpc.InterfaceDesc
+}
+
+// RowServer returns a server stub for Row.
+// It converts an implementation of RowServerMethods into
+// an object that may be used by rpc.Server.
+func RowServer(impl RowServerMethods) RowServerStub {
+ stub := implRowServerStub{
+ impl: impl,
+ }
+ // Initialize GlobState; always check the stub itself first, to handle the
+ // case where the user has the Glob method defined in their VDL source.
+ if gs := rpc.NewGlobState(stub); gs != nil {
+ stub.gs = gs
+ } else if gs := rpc.NewGlobState(impl); gs != nil {
+ stub.gs = gs
+ }
+ return stub
+}
+
+type implRowServerStub struct {
+ impl RowServerMethods
+ gs *rpc.GlobState
+}
+
+func (s implRowServerStub) Exists(ctx *context.T, call rpc.ServerCall, i0 int32) (bool, error) {
+ return s.impl.Exists(ctx, call, i0)
+}
+
+func (s implRowServerStub) Get(ctx *context.T, call rpc.ServerCall, i0 int32) ([]byte, error) {
+ return s.impl.Get(ctx, call, i0)
+}
+
+func (s implRowServerStub) Put(ctx *context.T, call rpc.ServerCall, i0 int32, i1 []byte) error {
+ return s.impl.Put(ctx, call, i0, i1)
+}
+
+func (s implRowServerStub) Delete(ctx *context.T, call rpc.ServerCall, i0 int32) error {
+ return s.impl.Delete(ctx, call, i0)
+}
+
+func (s implRowServerStub) Globber() *rpc.GlobState {
+ return s.gs
+}
+
+func (s implRowServerStub) Describe__() []rpc.InterfaceDesc {
+ return []rpc.InterfaceDesc{RowDesc}
+}
+
+// RowDesc describes the Row interface.
+var RowDesc rpc.InterfaceDesc = descRow
+
+// descRow hides the desc to keep godoc clean.
+var descRow = rpc.InterfaceDesc{
+ Name: "Row",
+ PkgPath: "v.io/v23/services/syncbase/nosql",
+ Doc: "// Row represents a single row in a Table.\n// All access checks are performed against the most specific matching prefix\n// permissions in the Table.\n// SchemaVersion is the version number that the client expects the database\n// to be at. To disable schema version checking, pass -1.\n// NOTE(sadovsky): Currently we send []byte values over the wire for Get, Put,\n// and Scan. If there's a way to avoid encoding/decoding on the server side, we\n// can use vdl.Value everywhere without sacrificing performance.",
+ Methods: []rpc.MethodDesc{
+ {
+ Name: "Exists",
+ Doc: "// Exists returns true only if this Row exists. Insufficient permissions\n// cause Exists to return false instead of an error.\n// Note, Exists on Row requires read permissions, unlike higher levels of\n// hierarchy which require resolve, because Row existence usually carries\n// more information.\n// TODO(ivanpi): Exists may fail with an error if higher levels of hierarchy\n// do not exist.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ },
+ OutArgs: []rpc.ArgDesc{
+ {"", ``}, // bool
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "Get",
+ Doc: "// Get returns the value for this Row.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ },
+ OutArgs: []rpc.ArgDesc{
+ {"", ``}, // []byte
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Read"))},
+ },
+ {
+ Name: "Put",
+ Doc: "// Put writes the given value for this Row.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ {"value", ``}, // []byte
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ {
+ Name: "Delete",
+ Doc: "// Delete deletes this Row.",
+ InArgs: []rpc.ArgDesc{
+ {"schemaVersion", ``}, // int32
+ },
+ Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
+ },
+ },
+}
+
+var __VDLInitCalled bool
+
+// __VDLInit performs vdl initialization. It is safe to call multiple times.
+// If you have an init ordering issue, just insert the following line verbatim
+// into your source files in this package, right after the "package foo" clause:
+//
+// var _ = __VDLInit()
+//
+// The purpose of this function is to ensure that vdl initialization occurs in
+// the right order, and very early in the init sequence. In particular, vdl
+// registration and package variable initialization needs to occur before
+// functions like vdl.TypeOf will work properly.
+//
+// This function returns a dummy value, so that it can be used to initialize the
+// first var in the file, to take advantage of Go's defined init order.
+func __VDLInit() struct{} {
+ if __VDLInitCalled {
+ return struct{}{}
+ }
+ __VDLInitCalled = true
+
+ // Register types.
+ vdl.Register((*BatchOptions)(nil))
+ vdl.Register((*PrefixPermissions)(nil))
+ vdl.Register((*KeyValue)(nil))
+ vdl.Register((*TableRow)(nil))
+ vdl.Register((*SyncgroupSpec)(nil))
+ vdl.Register((*SyncgroupMemberInfo)(nil))
+ vdl.Register((*ResolverType)(nil))
+ vdl.Register((*BatchSource)(nil))
+ vdl.Register((*BatchInfo)(nil))
+ vdl.Register((*ValueState)(nil))
+ vdl.Register((*Value)(nil))
+ vdl.Register((*RowOp)(nil))
+ vdl.Register((*ScanOp)(nil))
+ vdl.Register((*Operation)(nil))
+ vdl.Register((*RowInfo)(nil))
+ vdl.Register((*ConflictData)(nil))
+ vdl.Register((*ConflictInfo)(nil))
+ vdl.Register((*ValueSelection)(nil))
+ vdl.Register((*ResolutionInfo)(nil))
+ vdl.Register((*CrRule)(nil))
+ vdl.Register((*CrPolicy)(nil))
+ vdl.Register((*SchemaMetadata)(nil))
+ vdl.Register((*BlobRef)(nil))
+ vdl.Register((*BlobFetchState)(nil))
+ vdl.Register((*BlobFetchStatus)(nil))
+ vdl.Register((*StoreChange)(nil))
+
+ // Set error format strings.
+ i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrBoundToBatch.ID), "{1:}{2:} bound to batch")
+ i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrNotBoundToBatch.ID), "{1:}{2:} not bound to batch")
+ i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrReadOnlyBatch.ID), "{1:}{2:} batch is read-only")
+ i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrConcurrentBatch.ID), "{1:}{2:} concurrent batch")
+ i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrSchemaVersionMismatch.ID), "{1:}{2:} actual schema version does not match the provided one")
+ i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrBlobNotCommitted.ID), "{1:}{2:} blob is not yet committed")
+ i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrSyncgroupJoinFailed.ID), "{1:}{2:} syncgroup join failed")
+
+ return struct{}{}
+}
diff --git a/services/syncbase/syncbase.vdl.go b/services/syncbase/syncbase.vdl.go
index 22c6559..70d7847 100644
--- a/services/syncbase/syncbase.vdl.go
+++ b/services/syncbase/syncbase.vdl.go
@@ -62,76 +62,115 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("NtpHost")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.NtpHost), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.NtpHost == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.NtpHost), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- var wireValue4 time_2.Time
- if err := time_2.TimeFromNative(&wireValue4, m.Now); err != nil {
+ var wireValue5 time_2.Time
+ if err := time_2.TimeFromNative(&wireValue5, m.Now); err != nil {
return err
}
- keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Now")
+ keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Now")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue4.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var8 := (wireValue5 == time_2.Time{})
+ if var8 {
+ if err := fieldTarget7.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue5.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
return err
}
}
- var wireValue7 time_2.Duration
- if err := time_2.DurationFromNative(&wireValue7, m.ElapsedTime); err != nil {
+ var wireValue9 time_2.Duration
+ if err := time_2.DurationFromNative(&wireValue9, m.ElapsedTime); err != nil {
return err
}
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("ElapsedTime")
+ keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("ElapsedTime")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue7.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
- return err
- }
- }
- keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("DoNtpUpdate")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget11.FromBool(bool(m.DoNtpUpdate), tt.NonOptional().Field(3).Type); err != nil {
- return err
+ var12 := (wireValue9 == time_2.Duration{})
+ if var12 {
+ if err := fieldTarget11.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue9.FillVDLTarget(fieldTarget11, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
return err
}
}
- keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("DoLocalUpdate")
+ keyTarget13, fieldTarget14, err := fieldsTarget1.StartField("DoNtpUpdate")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget13.FromBool(bool(m.DoLocalUpdate), tt.NonOptional().Field(4).Type); err != nil {
+
+ var15 := (m.DoNtpUpdate == false)
+ if var15 {
+ if err := fieldTarget14.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget14.FromBool(bool(m.DoNtpUpdate), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget13, fieldTarget14); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
+ }
+ keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("DoLocalUpdate")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var18 := (m.DoLocalUpdate == false)
+ if var18 {
+ if err := fieldTarget17.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget17.FromBool(bool(m.DoLocalUpdate), tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
return err
}
}
@@ -196,6 +235,10 @@
return nil
}
+func (t *DevModeUpdateVClockOptsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = DevModeUpdateVClockOpts{}
+ return nil
+}
// BatchOptions configures a batch.
// TODO(sadovsky): Add more options, e.g. to configure isolation, timeouts,
@@ -226,28 +269,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Hint")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Hint), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Hint == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Hint), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("ReadOnly")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("ReadOnly")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromBool(bool(m.ReadOnly), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.ReadOnly == false)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromBool(bool(m.ReadOnly), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -297,6 +355,10 @@
return nil
}
+func (t *BatchOptionsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BatchOptions{}
+ return nil
+}
// PrefixPermissions represents a pair of (prefix, perms).
type PrefixPermissions struct {
@@ -314,29 +376,47 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Prefix")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Prefix), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Prefix == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Prefix), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Perms")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Perms")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Perms.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var var7 bool
+ if len(m.Perms) == 0 {
+ var7 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Perms.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -386,6 +466,10 @@
return nil
}
+func (t *PrefixPermissionsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = PrefixPermissions{}
+ return nil
+}
// KeyValue is a key-value pair.
type KeyValue struct {
@@ -403,29 +487,47 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Key == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Value")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Value")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromBytes([]byte(m.Value), tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var var7 bool
+ if len(m.Value) == 0 {
+ var7 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget6.FromBytes([]byte(m.Value), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -475,6 +577,10 @@
return nil
}
+func (t *KeyValueTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = KeyValue{}
+ return nil
+}
// CollectionRow encapsulates the collection name and row key or row prefix.
type CollectionRow struct {
@@ -492,28 +598,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("CollectionName")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.CollectionName), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.CollectionName == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.CollectionName), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Row")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Row")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Row), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Row == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Row), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -563,6 +684,10 @@
return nil
}
+func (t *CollectionRowTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = CollectionRow{}
+ return nil
+}
// SyncgroupSpec contains the specification for a syncgroup.
type SyncgroupSpec struct {
@@ -597,100 +722,148 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Description")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Description), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Description == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Description), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Perms")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Perms")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Perms.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var var7 bool
+ if len(m.Perms) == 0 {
+ var7 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Perms.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Prefixes")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Prefixes")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget8, err := fieldTarget7.StartList(tt.NonOptional().Field(2).Type, len(m.Prefixes))
- if err != nil {
- return err
+ var var10 bool
+ if len(m.Prefixes) == 0 {
+ var10 = true
}
- for i, elem10 := range m.Prefixes {
- elemTarget9, err := listTarget8.StartElem(i)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget11, err := fieldTarget9.StartList(tt.NonOptional().Field(2).Type, len(m.Prefixes))
if err != nil {
return err
}
+ for i, elem13 := range m.Prefixes {
+ elemTarget12, err := listTarget11.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(2).Type.Elem()); err != nil {
- return err
+ if err := elem13.FillVDLTarget(elemTarget12, tt.NonOptional().Field(2).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget11.FinishElem(elemTarget12); err != nil {
+ return err
+ }
}
- if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ if err := fieldTarget9.FinishList(listTarget11); err != nil {
return err
}
}
- if err := fieldTarget7.FinishList(listTarget8); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("MountTables")
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("MountTables")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget13, err := fieldTarget12.StartList(tt.NonOptional().Field(3).Type, len(m.MountTables))
- if err != nil {
- return err
+ var var16 bool
+ if len(m.MountTables) == 0 {
+ var16 = true
}
- for i, elem15 := range m.MountTables {
- elemTarget14, err := listTarget13.StartElem(i)
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget17, err := fieldTarget15.StartList(tt.NonOptional().Field(3).Type, len(m.MountTables))
if err != nil {
return err
}
- if err := elemTarget14.FromString(string(elem15), tt.NonOptional().Field(3).Type.Elem()); err != nil {
- return err
+ for i, elem19 := range m.MountTables {
+ elemTarget18, err := listTarget17.StartElem(i)
+ if err != nil {
+ return err
+ }
+ if err := elemTarget18.FromString(string(elem19), tt.NonOptional().Field(3).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget17.FinishElem(elemTarget18); err != nil {
+ return err
+ }
}
- if err := listTarget13.FinishElem(elemTarget14); err != nil {
+ if err := fieldTarget15.FinishList(listTarget17); err != nil {
return err
}
}
- if err := fieldTarget12.FinishList(listTarget13); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
- keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("IsPrivate")
+ keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("IsPrivate")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget17.FromBool(bool(m.IsPrivate), tt.NonOptional().Field(4).Type); err != nil {
- return err
+
+ var22 := (m.IsPrivate == false)
+ if var22 {
+ if err := fieldTarget21.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget21.FromBool(bool(m.IsPrivate), tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
return err
}
}
@@ -755,6 +928,10 @@
return nil
}
+func (t *SyncgroupSpecTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SyncgroupSpec{}
+ return nil
+}
// []CollectionRow
type __VDLTarget1_list struct {
@@ -788,6 +965,10 @@
return nil
}
+func (t *__VDLTarget1_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []CollectionRow(nil)
+ return nil
+}
// SyncgroupMemberInfo contains per-member metadata.
type SyncgroupMemberInfo struct {
@@ -805,28 +986,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("SyncPriority")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromUint(uint64(m.SyncPriority), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.SyncPriority == byte(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromUint(uint64(m.SyncPriority), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("IsServer")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("IsServer")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromBool(bool(m.IsServer), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.IsServer == false)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromBool(bool(m.IsServer), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -876,6 +1072,10 @@
return nil
}
+func (t *SyncgroupMemberInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SyncgroupMemberInfo{}
+ return nil
+}
// ResolverType defines the possible conflict resolution policies.
// A Conflict is defined as presence of two independent sets of updates
@@ -970,11 +1170,15 @@
case "Defer":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum v.io/v23/services/syncbase.ResolverType", src)
+ return fmt.Errorf("label %s not in enum ResolverType", src)
}
return nil
}
+func (t *ResolverTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ResolverTypeLastWins
+ return nil
+}
// BatchSource represents where the batch was committed.
type BatchSource int
@@ -1051,11 +1255,15 @@
case "Remote":
*t.Value = 1
default:
- return fmt.Errorf("label %s not in enum v.io/v23/services/syncbase.BatchSource", src)
+ return fmt.Errorf("label %s not in enum BatchSource", src)
}
return nil
}
+func (t *BatchSourceTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BatchSourceLocal
+ return nil
+}
type BatchInfo struct {
// Id is an identifier for a batch contained in a conflict. It is
@@ -1079,41 +1287,64 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Id")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromUint(uint64(m.Id), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Id == uint64(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromUint(uint64(m.Id), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Hint")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Hint), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Source")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Hint")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Source.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
+ var7 := (m.Hint == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Hint), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Source")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var10 := (m.Source == BatchSourceLocal)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Source.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -1168,6 +1399,10 @@
return nil
}
+func (t *BatchInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BatchInfo{}
+ return nil
+}
// ValueState represents the state for Value object providing information about
// whether the Value object's Byte field is empty or not.
@@ -1261,11 +1496,15 @@
case "Unknown":
*t.Value = 3
default:
- return fmt.Errorf("label %s not in enum v.io/v23/services/syncbase.ValueState", src)
+ return fmt.Errorf("label %s not in enum ValueState", src)
}
return nil
}
+func (t *ValueStateTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ValueStateExists
+ return nil
+}
// Value contains the encoded bytes for a row's value stored in syncbase.
type Value struct {
@@ -1288,48 +1527,74 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("State")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.State == ValueStateExists)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Bytes")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Bytes")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromBytes([]byte(m.Bytes), tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var var7 bool
+ if len(m.Bytes) == 0 {
+ var7 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget6.FromBytes([]byte(m.Bytes), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- var wireValue6 time_2.Time
- if err := time_2.TimeFromNative(&wireValue6, m.WriteTs); err != nil {
+ var wireValue8 time_2.Time
+ if err := time_2.TimeFromNative(&wireValue8, m.WriteTs); err != nil {
return err
}
- keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("WriteTs")
+ keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("WriteTs")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue6.FillVDLTarget(fieldTarget8, tt.NonOptional().Field(2).Type); err != nil {
- return err
+ var11 := (wireValue8 == time_2.Time{})
+ if var11 {
+ if err := fieldTarget10.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue8.FillVDLTarget(fieldTarget10, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
return err
}
}
@@ -1384,6 +1649,10 @@
return nil
}
+func (t *ValueTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Value{}
+ return nil
+}
// RowOp represents a read or write operation on a row corresponding to the
// given key.
@@ -1410,69 +1679,61 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Key == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("LocalValue")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("LocalValue")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.LocalValue == nil {
- if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
+ var7 := (m.LocalValue == (*Value)(nil))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- if err := m.LocalValue.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
+
+ if err := m.LocalValue.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
return err
}
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("RemoteValue")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("RemoteValue")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.RemoteValue == nil {
- if err := fieldTarget7.FromNil(tt.NonOptional().Field(2).Type); err != nil {
+ var10 := (m.RemoteValue == (*Value)(nil))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
return err
}
} else {
- if err := m.RemoteValue.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("AncestorValue")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if m.AncestorValue == nil {
- if err := fieldTarget9.FromNil(tt.NonOptional().Field(3).Type); err != nil {
- return err
- }
- } else {
- if err := m.AncestorValue.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
+ if err := m.RemoteValue.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
return err
}
}
@@ -1480,6 +1741,27 @@
return err
}
}
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("AncestorValue")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var13 := (m.AncestorValue == (*Value)(nil))
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.AncestorValue.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -1536,6 +1818,10 @@
return nil
}
+func (t *RowOpTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = RowOp{}
+ return nil
+}
// Optional Value
type __VDLTarget2_optional struct {
@@ -1561,10 +1847,8 @@
return nil
}
-func (t *__VDLTarget2_optional) FromNil(tt *vdl.Type) error {
-
- *t.Value = nil
-
+func (t *__VDLTarget2_optional) FromZero(tt *vdl.Type) error {
+ *t.Value = (*Value)(nil)
return nil
}
@@ -1586,28 +1870,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Start")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Start), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Start == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Start), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Limit")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Limit")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Limit), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Limit == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Limit), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1657,6 +1956,10 @@
return nil
}
+func (t *ScanOpTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ScanOp{}
+ return nil
+}
type (
// Operation represents any single field of the Operation union type.
@@ -1845,6 +2148,10 @@
return nil
}
+func (t *OperationTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Operation(OperationRead{})
+ return nil
+}
type operationTargetFactory struct{}
@@ -1880,50 +2187,81 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Op")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- unionValue4 := m.Op
- if unionValue4 == nil {
- unionValue4 = OperationRead{}
+ var var4 bool
+ if field, ok := m.Op.(OperationRead); ok {
+
+ var5 := true
+ var6 := (field.Value.Key == "")
+ var5 = var5 && var6
+ var7 := (field.Value.LocalValue == (*Value)(nil))
+ var5 = var5 && var7
+ var8 := (field.Value.RemoteValue == (*Value)(nil))
+ var5 = var5 && var8
+ var9 := (field.Value.AncestorValue == (*Value)(nil))
+ var5 = var5 && var9
+ var4 = var5
}
- if err := unionValue4.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ unionValue10 := m.Op
+ if unionValue10 == nil {
+ unionValue10 = OperationRead{}
+ }
+ if err := unionValue10.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("BatchIds")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("BatchIds")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget7, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.BatchIds))
- if err != nil {
- return err
+ var var13 bool
+ if len(m.BatchIds) == 0 {
+ var13 = true
}
- for i, elem9 := range m.BatchIds {
- elemTarget8, err := listTarget7.StartElem(i)
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget14, err := fieldTarget12.StartList(tt.NonOptional().Field(1).Type, len(m.BatchIds))
if err != nil {
return err
}
- if err := elemTarget8.FromUint(uint64(elem9), tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ for i, elem16 := range m.BatchIds {
+ elemTarget15, err := listTarget14.StartElem(i)
+ if err != nil {
+ return err
+ }
+ if err := elemTarget15.FromUint(uint64(elem16), tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget14.FinishElem(elemTarget15); err != nil {
+ return err
+ }
}
- if err := listTarget7.FinishElem(elemTarget8); err != nil {
+ if err := fieldTarget12.FinishList(listTarget14); err != nil {
return err
}
}
- if err := fieldTarget6.FinishList(listTarget7); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
@@ -1973,6 +2311,12 @@
return nil
}
+func (t *RowInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = RowInfo{
+ Op: OperationRead{},
+ }
+ return nil
+}
// []uint64
type __VDLTarget3_list struct {
@@ -2006,6 +2350,10 @@
return nil
}
+func (t *__VDLTarget3_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []uint64(nil)
+ return nil
+}
type (
// ConflictData represents any single field of the ConflictData union type.
@@ -2147,6 +2495,10 @@
return nil
}
+func (t *ConflictDataTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ConflictData(ConflictDataBatch{})
+ return nil
+}
type conflictDataTargetFactory struct{}
@@ -2182,33 +2534,53 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Data")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- unionValue4 := m.Data
- if unionValue4 == nil {
- unionValue4 = ConflictDataBatch{}
+ var var4 bool
+ if field, ok := m.Data.(ConflictDataBatch); ok {
+
+ var5 := (field.Value == BatchInfo{})
+ var4 = var5
}
- if err := unionValue4.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ unionValue6 := m.Data
+ if unionValue6 == nil {
+ unionValue6 = ConflictDataBatch{}
+ }
+ if err := unionValue6.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Continued")
+ keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("Continued")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget6.FromBool(bool(m.Continued), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var9 := (m.Continued == false)
+ if var9 {
+ if err := fieldTarget8.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget8.FromBool(bool(m.Continued), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
return err
}
}
@@ -2258,6 +2630,12 @@
return nil
}
+func (t *ConflictInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ConflictInfo{
+ Data: ConflictDataBatch{},
+ }
+ return nil
+}
// ValueSelection represents the value that was selected as the final resolution
// for a conflict.
@@ -2343,11 +2721,15 @@
case "Other":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum v.io/v23/services/syncbase.ValueSelection", src)
+ return fmt.Errorf("label %s not in enum ValueSelection", src)
}
return nil
}
+func (t *ValueSelectionTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ValueSelectionLocal
+ return nil
+}
// ResolutionInfo contains the application’s reply to a conflict for a key,
// providing the resolution value. The resolution may be over a group of keys
@@ -2378,63 +2760,88 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Key == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Selection")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Selection")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Selection.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Result")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
-
- if m.Result == nil {
- if err := fieldTarget7.FromNil(tt.NonOptional().Field(2).Type); err != nil {
+ var7 := (m.Selection == ValueSelectionLocal)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- if err := m.Result.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
+
+ if err := m.Selection.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
return err
}
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Continued")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Result")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget9.FromBool(bool(m.Continued), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var10 := (m.Result == (*Value)(nil))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Result.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Continued")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var13 := (m.Continued == false)
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget12.FromBool(bool(m.Continued), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -2491,6 +2898,10 @@
return nil
}
+func (t *ResolutionInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ResolutionInfo{}
+ return nil
+}
// CrRule provides a filter and the type of resolution to perform for a row
// under conflict that passes the filter.
@@ -2517,56 +2928,87 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("CollectionName")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.CollectionName), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.CollectionName == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.CollectionName), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("KeyPrefix")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.KeyPrefix), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Type")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromString(string(m.Type), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Resolver")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("KeyPrefix")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Resolver.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
+ var7 := (m.KeyPrefix == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.KeyPrefix), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Type")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var10 := (m.Type == "")
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromString(string(m.Type), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Resolver")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var13 := (m.Resolver == ResolverTypeLastWins)
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Resolver.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -2623,6 +3065,10 @@
return nil
}
+func (t *CrRuleTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = CrRule{}
+ return nil
+}
// For a given row with a conflict, all rules are matched against the row.
// If no rules match the row, we default to "LastWins". If multiple
@@ -2644,32 +3090,42 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rules")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget4, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.Rules))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.Rules) == 0 {
+ var4 = true
}
- for i, elem6 := range m.Rules {
- elemTarget5, err := listTarget4.StartElem(i)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget5, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.Rules))
if err != nil {
return err
}
+ for i, elem7 := range m.Rules {
+ elemTarget6, err := listTarget5.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem6.FillVDLTarget(elemTarget5, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ if err := elem7.FillVDLTarget(elemTarget6, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget5.FinishElem(elemTarget6); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishList(listTarget5); err != nil {
return err
}
- if err := listTarget4.FinishElem(elemTarget5); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishList(listTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -2716,6 +3172,10 @@
return nil
}
+func (t *CrPolicyTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = CrPolicy{}
+ return nil
+}
// []CrRule
type __VDLTarget4_list struct {
@@ -2749,6 +3209,10 @@
return nil
}
+func (t *__VDLTarget4_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []CrRule(nil)
+ return nil
+}
// SchemaMetadata maintains metadata related to the schema of a given database.
// There is one SchemaMetadata per database.
@@ -2770,29 +3234,49 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Version")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromInt(int64(m.Version), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Version == int32(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromInt(int64(m.Version), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Policy")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Policy")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Policy.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := true
+ var var8 bool
+ if len(m.Policy.Rules) == 0 {
+ var8 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ var7 = var7 && var8
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Policy.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -2842,6 +3326,10 @@
return nil
}
+func (t *SchemaMetadataTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SchemaMetadata{}
+ return nil
+}
// BlobRef is a reference to a blob.
type BlobRef string
@@ -2876,6 +3364,10 @@
return nil
}
+func (t *BlobRefTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BlobRef("")
+ return nil
+}
// BlobFetchState represents the state transitions of a blob fetch.
type BlobFetchState int
@@ -2968,11 +3460,15 @@
case "Done":
*t.Value = 3
default:
- return fmt.Errorf("label %s not in enum v.io/v23/services/syncbase.BlobFetchState", src)
+ return fmt.Errorf("label %s not in enum BlobFetchState", src)
}
return nil
}
+func (t *BlobFetchStateTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BlobFetchStatePending
+ return nil
+}
// BlobFetchStatus describes the progress of an asynchronous blob fetch.
type BlobFetchStatus struct {
@@ -2991,41 +3487,64 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("State")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.State == BlobFetchStatePending)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Received")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Received")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromInt(int64(m.Received), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Received == int64(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromInt(int64(m.Received), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Total")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Total")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromInt(int64(m.Total), tt.NonOptional().Field(2).Type); err != nil {
- return err
+
+ var10 := (m.Total == int64(0))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromInt(int64(m.Total), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -3080,6 +3599,10 @@
return nil
}
+func (t *BlobFetchStatusTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BlobFetchStatus{}
+ return nil
+}
// StoreChange is the new value for a watched entity.
// TODO(rogulenko): Consider adding the Shell state.
@@ -3103,29 +3626,47 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Value")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromBytes([]byte(m.Value), tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var var4 bool
+ if len(m.Value) == 0 {
+ var4 = true
+ }
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget3.FromBytes([]byte(m.Value), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("FromSync")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("FromSync")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromBool(bool(m.FromSync), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.FromSync == false)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromBool(bool(m.FromSync), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -3175,41 +3716,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroDevModeUpdateVClockOpts = DevModeUpdateVClockOpts{}
- __VDLZeroBatchOptions = BatchOptions{}
- __VDLZeroPrefixPermissions = PrefixPermissions{}
- __VDLZeroKeyValue = KeyValue{}
- __VDLZeroCollectionRow = CollectionRow{}
- __VDLZeroSyncgroupSpec = SyncgroupSpec{}
- __VDLZeroSyncgroupMemberInfo = SyncgroupMemberInfo{}
- __VDLZeroResolverType = ResolverTypeLastWins
- __VDLZeroBatchSource = BatchSourceLocal
- __VDLZeroBatchInfo = BatchInfo{}
- __VDLZeroValueState = ValueStateExists
- __VDLZeroValue = Value{}
- __VDLZeroRowOp = RowOp{}
- __VDLZeroScanOp = ScanOp{}
- __VDLZeroOperation = Operation(OperationRead{})
- __VDLZeroRowInfo = RowInfo{
- Op: OperationRead{},
- }
- __VDLZeroConflictData = ConflictData(ConflictDataBatch{})
- __VDLZeroConflictInfo = ConflictInfo{
- Data: ConflictDataBatch{},
- }
- __VDLZeroValueSelection = ValueSelectionLocal
- __VDLZeroResolutionInfo = ResolutionInfo{}
- __VDLZeroCrRule = CrRule{}
- __VDLZeroCrPolicy = CrPolicy{}
- __VDLZeroSchemaMetadata = SchemaMetadata{}
- __VDLZeroBlobRef = BlobRef("")
- __VDLZeroBlobFetchState = BlobFetchStatePending
- __VDLZeroBlobFetchStatus = BlobFetchStatus{}
- __VDLZeroStoreChange = StoreChange{}
-)
+func (t *StoreChangeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = StoreChange{}
+ return nil
+}
//////////////////////////////////////////////////
// Const definitions
@@ -7081,6 +7591,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*DevModeUpdateVClockOpts)(nil))
diff --git a/services/tidyable/.api b/services/tidyable/.api
index 3cda79b..6f87286 100644
--- a/services/tidyable/.api
+++ b/services/tidyable/.api
@@ -2,8 +2,8 @@
pkg tidyable, func TidyableServer(TidyableServerMethods) TidyableServerStub
pkg tidyable, type TidyableClientMethods interface { TidyNow }
pkg tidyable, type TidyableClientMethods interface, TidyNow(*context.T, ...rpc.CallOpt) error
-pkg tidyable, type TidyableClientStub interface { TidyNow }
pkg tidyable, type TidyableClientStub interface, TidyNow(*context.T, ...rpc.CallOpt) error
+pkg tidyable, type TidyableClientStub interface, unexported methods
pkg tidyable, type TidyableServerMethods interface { TidyNow }
pkg tidyable, type TidyableServerMethods interface, TidyNow(*context.T, rpc.ServerCall) error
pkg tidyable, type TidyableServerStub interface, Describe__() []rpc.InterfaceDesc
diff --git a/services/tidyable/tidyable.vdl.go b/services/tidyable/tidyable.vdl.go
index efdb05a..8ba05dc 100644
--- a/services/tidyable/tidyable.vdl.go
+++ b/services/tidyable/tidyable.vdl.go
@@ -145,6 +145,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
return struct{}{}
}
diff --git a/services/vtrace/.api b/services/vtrace/.api
index fcbb841..abb4dd5 100644
--- a/services/vtrace/.api
+++ b/services/vtrace/.api
@@ -7,14 +7,8 @@
pkg vtrace, type StoreAllTracesClientCall interface, RecvStream() interface { Advance() bool;; Value() vtrace.TraceRecord;; Err() error;}
pkg vtrace, type StoreAllTracesClientStream interface { RecvStream }
pkg vtrace, type StoreAllTracesClientStream interface, RecvStream() interface { Advance() bool;; Value() vtrace.TraceRecord;; Err() error;}
-pkg vtrace, type StoreAllTracesServerCall interface { GrantedBlessings, LocalEndpoint, RemoteEndpoint, Security, SendStream, Server, Suffix }
-pkg vtrace, type StoreAllTracesServerCall interface, GrantedBlessings() security.Blessings
-pkg vtrace, type StoreAllTracesServerCall interface, LocalEndpoint() naming.Endpoint
-pkg vtrace, type StoreAllTracesServerCall interface, RemoteEndpoint() naming.Endpoint
-pkg vtrace, type StoreAllTracesServerCall interface, Security() security.Call
pkg vtrace, type StoreAllTracesServerCall interface, SendStream() interface { Send(item vtrace.TraceRecord) error;}
-pkg vtrace, type StoreAllTracesServerCall interface, Server() Server
-pkg vtrace, type StoreAllTracesServerCall interface, Suffix() string
+pkg vtrace, type StoreAllTracesServerCall interface, unexported methods
pkg vtrace, type StoreAllTracesServerCallStub struct
pkg vtrace, type StoreAllTracesServerCallStub struct, embedded rpc.StreamServerCall
pkg vtrace, type StoreAllTracesServerStream interface { SendStream }
@@ -22,9 +16,9 @@
pkg vtrace, type StoreClientMethods interface { AllTraces, Trace }
pkg vtrace, type StoreClientMethods interface, AllTraces(*context.T, ...rpc.CallOpt) (StoreAllTracesClientCall, error)
pkg vtrace, type StoreClientMethods interface, Trace(*context.T, uniqueid.Id, ...rpc.CallOpt) (vtrace.TraceRecord, error)
-pkg vtrace, type StoreClientStub interface { AllTraces, Trace }
pkg vtrace, type StoreClientStub interface, AllTraces(*context.T, ...rpc.CallOpt) (StoreAllTracesClientCall, error)
pkg vtrace, type StoreClientStub interface, Trace(*context.T, uniqueid.Id, ...rpc.CallOpt) (vtrace.TraceRecord, error)
+pkg vtrace, type StoreClientStub interface, unexported methods
pkg vtrace, type StoreServerMethods interface { AllTraces, Trace }
pkg vtrace, type StoreServerMethods interface, AllTraces(*context.T, StoreAllTracesServerCall) error
pkg vtrace, type StoreServerMethods interface, Trace(*context.T, rpc.ServerCall, uniqueid.Id) (vtrace.TraceRecord, error)
diff --git a/services/vtrace/vtrace.vdl.go b/services/vtrace/vtrace.vdl.go
index 1b3c403..0da214a 100644
--- a/services/vtrace/vtrace.vdl.go
+++ b/services/vtrace/vtrace.vdl.go
@@ -292,6 +292,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
return struct{}{}
}
diff --git a/services/wakeup/.api b/services/wakeup/.api
index f5afef5..7166393 100644
--- a/services/wakeup/.api
+++ b/services/wakeup/.api
@@ -2,8 +2,8 @@
pkg wakeup, func WakeUpServer(WakeUpServerMethods) WakeUpServerStub
pkg wakeup, type WakeUpClientMethods interface { Register }
pkg wakeup, type WakeUpClientMethods interface, Register(*context.T, string, ...rpc.CallOpt) (string, error)
-pkg wakeup, type WakeUpClientStub interface { Register }
pkg wakeup, type WakeUpClientStub interface, Register(*context.T, string, ...rpc.CallOpt) (string, error)
+pkg wakeup, type WakeUpClientStub interface, unexported methods
pkg wakeup, type WakeUpServerMethods interface { Register }
pkg wakeup, type WakeUpServerMethods interface, Register(*context.T, rpc.ServerCall, string) (string, error)
pkg wakeup, type WakeUpServerStub interface, Describe__() []rpc.InterfaceDesc
diff --git a/services/wakeup/wakeup.vdl.go b/services/wakeup/wakeup.vdl.go
index 82fa20d..5291493 100644
--- a/services/wakeup/wakeup.vdl.go
+++ b/services/wakeup/wakeup.vdl.go
@@ -148,6 +148,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
return struct{}{}
}
diff --git a/services/watch/.api b/services/watch/.api
index 9974ca6..f54a364 100644
--- a/services/watch/.api
+++ b/services/watch/.api
@@ -8,12 +8,14 @@
pkg watch, method (*Change) MakeVDLTarget() vdl.Target
pkg watch, method (*ChangeTarget) FinishField(vdl.Target, vdl.Target) error
pkg watch, method (*ChangeTarget) FinishFields(vdl.FieldsTarget) error
+pkg watch, method (*ChangeTarget) FromZero(*vdl.Type) error
pkg watch, method (*ChangeTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg watch, method (*ChangeTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg watch, method (*GlobRequest) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg watch, method (*GlobRequest) MakeVDLTarget() vdl.Target
pkg watch, method (*GlobRequestTarget) FinishField(vdl.Target, vdl.Target) error
pkg watch, method (*GlobRequestTarget) FinishFields(vdl.FieldsTarget) error
+pkg watch, method (*GlobRequestTarget) FromZero(*vdl.Type) error
pkg watch, method (*GlobRequestTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg watch, method (*GlobRequestTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg watch, method (*GlobWatcherWatchGlobServerCallStub) Init(rpc.StreamServerCall)
@@ -21,6 +23,7 @@
pkg watch, method (*ResumeMarker) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg watch, method (*ResumeMarker) MakeVDLTarget() vdl.Target
pkg watch, method (*ResumeMarkerTarget) FromBytes([]byte, *vdl.Type) error
+pkg watch, method (*ResumeMarkerTarget) FromZero(*vdl.Type) error
pkg watch, type Change struct
pkg watch, type Change struct, Continued bool
pkg watch, type Change struct, Name string
@@ -40,8 +43,8 @@
pkg watch, type GlobRequestTarget struct, embedded vdl.TargetBase
pkg watch, type GlobWatcherClientMethods interface { WatchGlob }
pkg watch, type GlobWatcherClientMethods interface, WatchGlob(*context.T, GlobRequest, ...rpc.CallOpt) (GlobWatcherWatchGlobClientCall, error)
-pkg watch, type GlobWatcherClientStub interface { WatchGlob }
pkg watch, type GlobWatcherClientStub interface, WatchGlob(*context.T, GlobRequest, ...rpc.CallOpt) (GlobWatcherWatchGlobClientCall, error)
+pkg watch, type GlobWatcherClientStub interface, unexported methods
pkg watch, type GlobWatcherServerMethods interface { WatchGlob }
pkg watch, type GlobWatcherServerMethods interface, WatchGlob(*context.T, GlobWatcherWatchGlobServerCall, GlobRequest) error
pkg watch, type GlobWatcherServerStub interface { Describe__, WatchGlob }
@@ -54,14 +57,8 @@
pkg watch, type GlobWatcherWatchGlobClientCall interface, RecvStream() interface { Advance() bool;; Value() Change;; Err() error;}
pkg watch, type GlobWatcherWatchGlobClientStream interface { RecvStream }
pkg watch, type GlobWatcherWatchGlobClientStream interface, RecvStream() interface { Advance() bool;; Value() Change;; Err() error;}
-pkg watch, type GlobWatcherWatchGlobServerCall interface { GrantedBlessings, LocalEndpoint, RemoteEndpoint, Security, SendStream, Server, Suffix }
-pkg watch, type GlobWatcherWatchGlobServerCall interface, GrantedBlessings() security.Blessings
-pkg watch, type GlobWatcherWatchGlobServerCall interface, LocalEndpoint() naming.Endpoint
-pkg watch, type GlobWatcherWatchGlobServerCall interface, RemoteEndpoint() naming.Endpoint
-pkg watch, type GlobWatcherWatchGlobServerCall interface, Security() security.Call
pkg watch, type GlobWatcherWatchGlobServerCall interface, SendStream() interface { Send(item Change) error;}
-pkg watch, type GlobWatcherWatchGlobServerCall interface, Server() Server
-pkg watch, type GlobWatcherWatchGlobServerCall interface, Suffix() string
+pkg watch, type GlobWatcherWatchGlobServerCall interface, unexported methods
pkg watch, type GlobWatcherWatchGlobServerCallStub struct
pkg watch, type GlobWatcherWatchGlobServerCallStub struct, embedded rpc.StreamServerCall
pkg watch, type GlobWatcherWatchGlobServerStream interface { SendStream }
@@ -70,5 +67,5 @@
pkg watch, type ResumeMarkerTarget struct
pkg watch, type ResumeMarkerTarget struct, Value *ResumeMarker
pkg watch, type ResumeMarkerTarget struct, embedded vdl.TargetBase
-pkg watch, var ErrUnknownResumeMarker verror.IDAction
+pkg watch, var ErrUnknownResumeMarker unknown-type
pkg watch, var GlobWatcherDesc rpc.InterfaceDesc
diff --git a/services/watch/watch.vdl.go b/services/watch/watch.vdl.go
index 47f9034..73a71d5 100644
--- a/services/watch/watch.vdl.go
+++ b/services/watch/watch.vdl.go
@@ -194,6 +194,10 @@
return nil
}
+func (t *ResumeMarkerTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ResumeMarker(nil)
+ return nil
+}
// GlobRequest specifies which entities should be watched and, optionally,
// how to resume from a previous Watch call.
@@ -216,29 +220,47 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Pattern")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Pattern), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Pattern == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Pattern), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("ResumeMarker")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("ResumeMarker")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.ResumeMarker.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var var7 bool
+ if len(m.ResumeMarker) == 0 {
+ var7 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.ResumeMarker.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -288,6 +310,10 @@
return nil
}
+func (t *GlobRequestTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = GlobRequest{}
+ return nil
+}
// Change is the new value for a watched entity.
type Change struct {
@@ -320,72 +346,114 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("State")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromInt(int64(m.State), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Value")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("State")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.Value == nil {
- if err := fieldTarget7.FromNil(tt.NonOptional().Field(2).Type); err != nil {
+ var7 := (m.State == int32(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- if err := m.Value.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
+ if err := fieldTarget6.FromInt(int64(m.State), tt.NonOptional().Field(1).Type); err != nil {
return err
}
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("ResumeMarker")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Value")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.ResumeMarker.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
- return err
+ var10 := (m.Value == vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if m.Value == nil {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := m.Value.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("Continued")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("ResumeMarker")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget11.FromBool(bool(m.Continued), tt.NonOptional().Field(4).Type); err != nil {
+
+ var var13 bool
+ if len(m.ResumeMarker) == 0 {
+ var13 = true
+ }
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.ResumeMarker.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
+ }
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Continued")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var16 := (m.Continued == false)
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget15.FromBool(bool(m.Continued), tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
@@ -449,13 +517,12 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroResumeMarker = ResumeMarker(nil)
- __VDLZeroGlobRequest = GlobRequest{}
- __VDLZeroChange = Change{}
-)
+func (t *ChangeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Change{
+ Value: vom.RawBytesOf(vdl.ZeroValue(vdl.AnyType)),
+ }
+ return nil
+}
//////////////////////////////////////////////////
// Const definitions
@@ -731,6 +798,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*ResumeMarker)(nil))
diff --git a/syncbase/.api b/syncbase/.api
index db5cadb..a824ebc 100644
--- a/syncbase/.api
+++ b/syncbase/.api
@@ -17,20 +17,24 @@
pkg syncbase, method (*ConflictRowSet) MakeVDLTarget() vdl.Target
pkg syncbase, method (*ConflictRowSetTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*ConflictRowSetTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*ConflictRowSetTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ConflictRowSetTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*ConflictRowSetTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*ConflictRowTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*ConflictRowTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*ConflictRowTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ConflictRowTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*ConflictRowTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*ConflictScanSet) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*ConflictScanSet) MakeVDLTarget() vdl.Target
pkg syncbase, method (*ConflictScanSetTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*ConflictScanSetTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*ConflictScanSetTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ConflictScanSetTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*ConflictScanSetTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*ConflictTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*ConflictTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*ConflictTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ConflictTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*ConflictTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*InvalidScanStream) Advance() bool
@@ -42,12 +46,14 @@
pkg syncbase, method (*Resolution) MakeVDLTarget() vdl.Target
pkg syncbase, method (*ResolutionTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*ResolutionTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*ResolutionTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ResolutionTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*ResolutionTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*ResolvedRow) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg syncbase, method (*ResolvedRow) MakeVDLTarget() vdl.Target
pkg syncbase, method (*ResolvedRowTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*ResolvedRowTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*ResolvedRowTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ResolvedRowTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*ResolvedRowTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*Value) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -55,6 +61,7 @@
pkg syncbase, method (*Value) MakeVDLTarget() vdl.Target
pkg syncbase, method (*ValueTarget) FinishField(vdl.Target, vdl.Target) error
pkg syncbase, method (*ValueTarget) FinishFields(vdl.FieldsTarget) error
+pkg syncbase, method (*ValueTarget) FromZero(*vdl.Type) error
pkg syncbase, method (*ValueTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg syncbase, method (*ValueTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg syncbase, method (*WatchChange) Value(interface{}) error
diff --git a/syncbase/nosql/.api b/syncbase/nosql/.api
new file mode 100644
index 0000000..e420c51
--- /dev/null
+++ b/syncbase/nosql/.api
@@ -0,0 +1,263 @@
+pkg nosql, const DeleteChange ChangeType
+pkg nosql, const PutChange ChangeType
+pkg nosql, func NewDatabase(string, string, *Schema) *database
+pkg nosql, func NewValue(*context.T, interface{}) (*Value, error)
+pkg nosql, func Prefix(string) PrefixRange
+pkg nosql, func Range(string, string) RowRange
+pkg nosql, func RunInBatch(*context.T, Database, wire.BatchOptions, func(BatchDatabase) error) error
+pkg nosql, func SingleRow(string) RowRange
+pkg nosql, func ToWatchChange(watch.Change) WatchChange
+pkg nosql, func UUID() string
+pkg nosql, method (*Conflict) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*Conflict) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ConflictRow) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*ConflictRow) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ConflictRowSet) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*ConflictRowSet) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ConflictRowSetTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*ConflictRowSetTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*ConflictRowSetTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ConflictRowSetTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*ConflictRowSetTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*ConflictRowTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*ConflictRowTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*ConflictRowTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ConflictRowTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*ConflictRowTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*ConflictScanSet) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*ConflictScanSet) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ConflictScanSetTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*ConflictScanSetTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*ConflictScanSetTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ConflictScanSetTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*ConflictScanSetTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*ConflictTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*ConflictTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*ConflictTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ConflictTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*ConflictTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*InvalidScanStream) Advance() bool
+pkg nosql, method (*InvalidScanStream) Cancel()
+pkg nosql, method (*InvalidScanStream) Err() error
+pkg nosql, method (*InvalidScanStream) Key() string
+pkg nosql, method (*InvalidScanStream) Value(interface{}) error
+pkg nosql, method (*Resolution) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*Resolution) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ResolutionTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*ResolutionTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*ResolutionTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ResolutionTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*ResolutionTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*ResolvedRow) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*ResolvedRow) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ResolvedRowTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*ResolvedRowTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*ResolvedRowTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ResolvedRowTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*ResolvedRowTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*Value) FillVDLTarget(vdl.Target, *vdl.Type) error
+pkg nosql, method (*Value) Get(interface{}) error
+pkg nosql, method (*Value) MakeVDLTarget() vdl.Target
+pkg nosql, method (*ValueTarget) FinishField(vdl.Target, vdl.Target) error
+pkg nosql, method (*ValueTarget) FinishFields(vdl.FieldsTarget) error
+pkg nosql, method (*ValueTarget) FromZero(*vdl.Type) error
+pkg nosql, method (*ValueTarget) StartField(string) (vdl.Target, vdl.Target, error)
+pkg nosql, method (*ValueTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
+pkg nosql, method (*WatchChange) Value(interface{}) error
+pkg nosql, type BatchDatabase interface { Abort, Close, Commit, Exec, FullName, GetResumeMarker, ListTables, Name, Table }
+pkg nosql, type BatchDatabase interface, Abort(*context.T) error
+pkg nosql, type BatchDatabase interface, Close()
+pkg nosql, type BatchDatabase interface, Commit(*context.T) error
+pkg nosql, type BatchDatabase interface, Exec(*context.T, string, ...interface{}) ([]string, ResultStream, error)
+pkg nosql, type BatchDatabase interface, FullName() string
+pkg nosql, type BatchDatabase interface, GetResumeMarker(*context.T) (watch.ResumeMarker, error)
+pkg nosql, type BatchDatabase interface, ListTables(*context.T) ([]string, error)
+pkg nosql, type BatchDatabase interface, Name() string
+pkg nosql, type BatchDatabase interface, Table(string) Table
+pkg nosql, type Blob interface { Commit, Delete, Fetch, Get, Keep, Pin, Put, Ref, Size, Unpin }
+pkg nosql, type Blob interface, Commit(*context.T) error
+pkg nosql, type Blob interface, Delete(*context.T) error
+pkg nosql, type Blob interface, Fetch(*context.T, uint64) (BlobStatus, error)
+pkg nosql, type Blob interface, Get(*context.T, int64) (BlobReader, error)
+pkg nosql, type Blob interface, Keep(*context.T, uint64) error
+pkg nosql, type Blob interface, Pin(*context.T) error
+pkg nosql, type Blob interface, Put(*context.T) (BlobWriter, error)
+pkg nosql, type Blob interface, Ref() wire.BlobRef
+pkg nosql, type Blob interface, Size(*context.T) (int64, error)
+pkg nosql, type Blob interface, Unpin(*context.T) error
+pkg nosql, type BlobReader interface { Advance, Cancel, Err, Value }
+pkg nosql, type BlobReader interface, Advance() bool
+pkg nosql, type BlobReader interface, Cancel()
+pkg nosql, type BlobReader interface, Err() error
+pkg nosql, type BlobReader interface, Value() []byte
+pkg nosql, type BlobStatus interface { Advance, Cancel, Err, Value }
+pkg nosql, type BlobStatus interface, Advance() bool
+pkg nosql, type BlobStatus interface, Cancel()
+pkg nosql, type BlobStatus interface, Err() error
+pkg nosql, type BlobStatus interface, Value() wire.BlobFetchStatus
+pkg nosql, type BlobWriter interface { Close, Send }
+pkg nosql, type BlobWriter interface, Close() error
+pkg nosql, type BlobWriter interface, Send([]byte) error
+pkg nosql, type ChangeType uint32
+pkg nosql, type Conflict struct
+pkg nosql, type Conflict struct, Batches map[uint64]nosql.BatchInfo
+pkg nosql, type Conflict struct, ReadSet *ConflictRowSet
+pkg nosql, type Conflict struct, ScanSet *ConflictScanSet
+pkg nosql, type Conflict struct, WriteSet *ConflictRowSet
+pkg nosql, type ConflictResolver interface { OnConflict }
+pkg nosql, type ConflictResolver interface, OnConflict(*context.T, *Conflict) Resolution
+pkg nosql, type ConflictRow struct
+pkg nosql, type ConflictRow struct, AncestorValue Value
+pkg nosql, type ConflictRow struct, BatchIds []uint64
+pkg nosql, type ConflictRow struct, Key string
+pkg nosql, type ConflictRow struct, LocalValue Value
+pkg nosql, type ConflictRow struct, RemoteValue Value
+pkg nosql, type ConflictRowSet struct
+pkg nosql, type ConflictRowSet struct, ByBatch map[uint64][]ConflictRow
+pkg nosql, type ConflictRowSet struct, ByKey map[string]ConflictRow
+pkg nosql, type ConflictRowSetTarget struct
+pkg nosql, type ConflictRowSetTarget struct, Value *ConflictRowSet
+pkg nosql, type ConflictRowSetTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type ConflictRowSetTarget struct, embedded vdl.TargetBase
+pkg nosql, type ConflictRowTarget struct
+pkg nosql, type ConflictRowTarget struct, Value *ConflictRow
+pkg nosql, type ConflictRowTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type ConflictRowTarget struct, embedded vdl.TargetBase
+pkg nosql, type ConflictScanSet struct
+pkg nosql, type ConflictScanSet struct, ByBatch map[uint64][]nosql.ScanOp
+pkg nosql, type ConflictScanSetTarget struct
+pkg nosql, type ConflictScanSetTarget struct, Value *ConflictScanSet
+pkg nosql, type ConflictScanSetTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type ConflictScanSetTarget struct, embedded vdl.TargetBase
+pkg nosql, type ConflictTarget struct
+pkg nosql, type ConflictTarget struct, Value *Conflict
+pkg nosql, type ConflictTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type ConflictTarget struct, embedded vdl.TargetBase
+pkg nosql, type Database interface { BeginBatch, Blob, Close, Create, CreateBlob, Destroy, EnforceSchema, Exec, Exists, FullName, GetPermissions, GetResumeMarker, GetSyncgroupNames, ListTables, Name, PauseSync, ResumeSync, SetPermissions, Syncgroup, Table, Watch }
+pkg nosql, type Database interface, BeginBatch(*context.T, wire.BatchOptions) (BatchDatabase, error)
+pkg nosql, type Database interface, Blob(wire.BlobRef) Blob
+pkg nosql, type Database interface, Close()
+pkg nosql, type Database interface, Create(*context.T, access.Permissions) error
+pkg nosql, type Database interface, CreateBlob(*context.T) (Blob, error)
+pkg nosql, type Database interface, Destroy(*context.T) error
+pkg nosql, type Database interface, EnforceSchema(*context.T) error
+pkg nosql, type Database interface, Exec(*context.T, string, ...interface{}) ([]string, ResultStream, error)
+pkg nosql, type Database interface, Exists(*context.T) (bool, error)
+pkg nosql, type Database interface, FullName() string
+pkg nosql, type Database interface, GetPermissions(*context.T) (access.Permissions, string, error)
+pkg nosql, type Database interface, GetResumeMarker(*context.T) (watch.ResumeMarker, error)
+pkg nosql, type Database interface, GetSyncgroupNames(*context.T) ([]string, error)
+pkg nosql, type Database interface, ListTables(*context.T) ([]string, error)
+pkg nosql, type Database interface, Name() string
+pkg nosql, type Database interface, PauseSync(*context.T) error
+pkg nosql, type Database interface, ResumeSync(*context.T) error
+pkg nosql, type Database interface, SetPermissions(*context.T, access.Permissions, string) error
+pkg nosql, type Database interface, Syncgroup(string) Syncgroup
+pkg nosql, type Database interface, Table(string) Table
+pkg nosql, type Database interface, Watch(*context.T, string, string, watch.ResumeMarker) (WatchStream, error)
+pkg nosql, type DatabaseHandle interface { Close, Exec, FullName, GetResumeMarker, ListTables, Name, Table }
+pkg nosql, type DatabaseHandle interface, Close()
+pkg nosql, type DatabaseHandle interface, Exec(*context.T, string, ...interface{}) ([]string, ResultStream, error)
+pkg nosql, type DatabaseHandle interface, FullName() string
+pkg nosql, type DatabaseHandle interface, GetResumeMarker(*context.T) (watch.ResumeMarker, error)
+pkg nosql, type DatabaseHandle interface, ListTables(*context.T) ([]string, error)
+pkg nosql, type DatabaseHandle interface, Name() string
+pkg nosql, type DatabaseHandle interface, Table(string) Table
+pkg nosql, type InvalidScanStream struct
+pkg nosql, type InvalidScanStream struct, Error error
+pkg nosql, type PrefixPermissions struct
+pkg nosql, type PrefixPermissions struct, Perms access.Permissions
+pkg nosql, type PrefixPermissions struct, Prefix PrefixRange
+pkg nosql, type PrefixRange interface { Limit, Prefix, Start }
+pkg nosql, type PrefixRange interface, Limit() string
+pkg nosql, type PrefixRange interface, Prefix() string
+pkg nosql, type PrefixRange interface, Start() string
+pkg nosql, type Resolution struct
+pkg nosql, type Resolution struct, ResultSet map[string]ResolvedRow
+pkg nosql, type ResolutionTarget struct
+pkg nosql, type ResolutionTarget struct, Value *Resolution
+pkg nosql, type ResolutionTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type ResolutionTarget struct, embedded vdl.TargetBase
+pkg nosql, type ResolvedRow struct
+pkg nosql, type ResolvedRow struct, Key string
+pkg nosql, type ResolvedRow struct, Result *Value
+pkg nosql, type ResolvedRowTarget struct
+pkg nosql, type ResolvedRowTarget struct, Value *ResolvedRow
+pkg nosql, type ResolvedRowTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type ResolvedRowTarget struct, embedded vdl.TargetBase
+pkg nosql, type ResultStream interface { Advance, Cancel, Err, Result }
+pkg nosql, type ResultStream interface, Advance() bool
+pkg nosql, type ResultStream interface, Cancel()
+pkg nosql, type ResultStream interface, Err() error
+pkg nosql, type ResultStream interface, Result() []*vom.RawBytes
+pkg nosql, type Row interface { Delete, Exists, FullName, Get, Key, Put }
+pkg nosql, type Row interface, Delete(*context.T) error
+pkg nosql, type Row interface, Exists(*context.T) (bool, error)
+pkg nosql, type Row interface, FullName() string
+pkg nosql, type Row interface, Get(*context.T, interface{}) error
+pkg nosql, type Row interface, Key() string
+pkg nosql, type Row interface, Put(*context.T, interface{}) error
+pkg nosql, type RowRange interface { Limit, Start }
+pkg nosql, type RowRange interface, Limit() string
+pkg nosql, type RowRange interface, Start() string
+pkg nosql, type ScanStream interface { Advance, Cancel, Err, Key, Value }
+pkg nosql, type ScanStream interface, Advance() bool
+pkg nosql, type ScanStream interface, Cancel()
+pkg nosql, type ScanStream interface, Err() error
+pkg nosql, type ScanStream interface, Key() string
+pkg nosql, type ScanStream interface, Value(interface{}) error
+pkg nosql, type Schema struct
+pkg nosql, type Schema struct, Metadata wire.SchemaMetadata
+pkg nosql, type Schema struct, Resolver ConflictResolver
+pkg nosql, type Stream interface { Advance, Cancel, Err }
+pkg nosql, type Stream interface, Advance() bool
+pkg nosql, type Stream interface, Cancel()
+pkg nosql, type Stream interface, Err() error
+pkg nosql, type Syncgroup interface { Create, Destroy, Eject, GetMembers, GetSpec, Join, Leave, SetSpec }
+pkg nosql, type Syncgroup interface, Create(*context.T, wire.SyncgroupSpec, wire.SyncgroupMemberInfo) error
+pkg nosql, type Syncgroup interface, Destroy(*context.T) error
+pkg nosql, type Syncgroup interface, Eject(*context.T, string) error
+pkg nosql, type Syncgroup interface, GetMembers(*context.T) (map[string]wire.SyncgroupMemberInfo, error)
+pkg nosql, type Syncgroup interface, GetSpec(*context.T) (wire.SyncgroupSpec, string, error)
+pkg nosql, type Syncgroup interface, Join(*context.T, wire.SyncgroupMemberInfo) (wire.SyncgroupSpec, error)
+pkg nosql, type Syncgroup interface, Leave(*context.T) error
+pkg nosql, type Syncgroup interface, SetSpec(*context.T, wire.SyncgroupSpec, string) error
+pkg nosql, type Table interface { Create, Delete, DeletePrefixPermissions, DeleteRange, Destroy, Exists, FullName, Get, GetPermissions, GetPrefixPermissions, Name, Put, Row, Scan, SetPermissions, SetPrefixPermissions }
+pkg nosql, type Table interface, Create(*context.T, access.Permissions) error
+pkg nosql, type Table interface, Delete(*context.T, string) error
+pkg nosql, type Table interface, DeletePrefixPermissions(*context.T, PrefixRange) error
+pkg nosql, type Table interface, DeleteRange(*context.T, RowRange) error
+pkg nosql, type Table interface, Destroy(*context.T) error
+pkg nosql, type Table interface, Exists(*context.T) (bool, error)
+pkg nosql, type Table interface, FullName() string
+pkg nosql, type Table interface, Get(*context.T, string, interface{}) error
+pkg nosql, type Table interface, GetPermissions(*context.T) (access.Permissions, error)
+pkg nosql, type Table interface, GetPrefixPermissions(*context.T, string) ([]PrefixPermissions, error)
+pkg nosql, type Table interface, Name() string
+pkg nosql, type Table interface, Put(*context.T, string, interface{}) error
+pkg nosql, type Table interface, Row(string) Row
+pkg nosql, type Table interface, Scan(*context.T, RowRange) ScanStream
+pkg nosql, type Table interface, SetPermissions(*context.T, access.Permissions) error
+pkg nosql, type Table interface, SetPrefixPermissions(*context.T, PrefixRange, access.Permissions) error
+pkg nosql, type Value struct
+pkg nosql, type Value struct, Selection nosql.ValueSelection
+pkg nosql, type Value struct, State nosql.ValueState
+pkg nosql, type Value struct, Val []byte
+pkg nosql, type Value struct, WriteTs time.Time
+pkg nosql, type ValueTarget struct
+pkg nosql, type ValueTarget struct, Value *Value
+pkg nosql, type ValueTarget struct, embedded vdl.FieldsTargetBase
+pkg nosql, type ValueTarget struct, embedded vdl.TargetBase
+pkg nosql, type WatchChange struct
+pkg nosql, type WatchChange struct, ChangeType ChangeType
+pkg nosql, type WatchChange struct, Continued bool
+pkg nosql, type WatchChange struct, FromSync bool
+pkg nosql, type WatchChange struct, ResumeMarker watch.ResumeMarker
+pkg nosql, type WatchChange struct, Row string
+pkg nosql, type WatchChange struct, Table string
+pkg nosql, type WatchChange struct, ValueBytes []byte
+pkg nosql, type WatchStream interface { Advance, Cancel, Change, Err }
+pkg nosql, type WatchStream interface, Advance() bool
+pkg nosql, type WatchStream interface, Cancel()
+pkg nosql, type WatchStream interface, Change() WatchChange
+pkg nosql, type WatchStream interface, Err() error
diff --git a/syncbase/syncbase.vdl.go b/syncbase/syncbase.vdl.go
index 7a994f9..8b5899b 100644
--- a/syncbase/syncbase.vdl.go
+++ b/syncbase/syncbase.vdl.go
@@ -46,64 +46,98 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("State")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.State == syncbase.ValueStateExists)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.State.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Val")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Val")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromBytes([]byte(m.Val), tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var var7 bool
+ if len(m.Val) == 0 {
+ var7 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget6.FromBytes([]byte(m.Val), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- var wireValue6 time_2.Time
- if err := time_2.TimeFromNative(&wireValue6, m.WriteTs); err != nil {
+ var wireValue8 time_2.Time
+ if err := time_2.TimeFromNative(&wireValue8, m.WriteTs); err != nil {
return err
}
- keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("WriteTs")
+ keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("WriteTs")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue6.FillVDLTarget(fieldTarget8, tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
- return err
- }
- }
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Selection")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
+ var11 := (wireValue8 == time_2.Time{})
+ if var11 {
+ if err := fieldTarget10.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
- if err := m.Selection.FillVDLTarget(fieldTarget10, tt.NonOptional().Field(3).Type); 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
}
}
+ keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("Selection")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var14 := (m.Selection == syncbase.ValueSelectionLocal)
+ if var14 {
+ if err := fieldTarget13.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Selection.FillVDLTarget(fieldTarget13, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -160,6 +194,10 @@
return nil
}
+func (t *ValueTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Value{}
+ return nil
+}
// ConflictRow represents a row under conflict.
// Key is the key for the row.
@@ -187,84 +225,174 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Key == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("LocalValue")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("LocalValue")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.LocalValue.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := true
+ var8 := (m.LocalValue.State == syncbase.ValueStateExists)
+ var7 = var7 && var8
+ var var9 bool
+ if len(m.LocalValue.Val) == 0 {
+ var9 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ var7 = var7 && var9
+ var wireValue10 time_2.Time
+ if err := time_2.TimeFromNative(&wireValue10, m.LocalValue.WriteTs); err != nil {
+ return fmt.Errorf("error converting m.LocalValue.WriteTs to wiretype")
+ }
+
+ var11 := (wireValue10 == time_2.Time{})
+ var7 = var7 && var11
+ var12 := (m.LocalValue.Selection == syncbase.ValueSelectionLocal)
+ var7 = var7 && var12
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.LocalValue.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("RemoteValue")
+ keyTarget13, fieldTarget14, err := fieldsTarget1.StartField("RemoteValue")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.RemoteValue.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
- return err
+ var15 := true
+ var16 := (m.RemoteValue.State == syncbase.ValueStateExists)
+ var15 = var15 && var16
+ var var17 bool
+ if len(m.RemoteValue.Val) == 0 {
+ var17 = true
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ var15 = var15 && var17
+ var wireValue18 time_2.Time
+ if err := time_2.TimeFromNative(&wireValue18, m.RemoteValue.WriteTs); err != nil {
+ return fmt.Errorf("error converting m.RemoteValue.WriteTs to wiretype")
+ }
+
+ var19 := (wireValue18 == time_2.Time{})
+ var15 = var15 && var19
+ var20 := (m.RemoteValue.Selection == syncbase.ValueSelectionLocal)
+ var15 = var15 && var20
+ if var15 {
+ if err := fieldTarget14.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.RemoteValue.FillVDLTarget(fieldTarget14, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget13, fieldTarget14); err != nil {
return err
}
}
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("AncestorValue")
+ keyTarget21, fieldTarget22, err := fieldsTarget1.StartField("AncestorValue")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.AncestorValue.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
- return err
+ var23 := true
+ var24 := (m.AncestorValue.State == syncbase.ValueStateExists)
+ var23 = var23 && var24
+ var var25 bool
+ if len(m.AncestorValue.Val) == 0 {
+ var25 = true
}
- if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
+ var23 = var23 && var25
+ var wireValue26 time_2.Time
+ if err := time_2.TimeFromNative(&wireValue26, m.AncestorValue.WriteTs); err != nil {
+ return fmt.Errorf("error converting m.AncestorValue.WriteTs to wiretype")
+ }
+
+ var27 := (wireValue26 == time_2.Time{})
+ var23 = var23 && var27
+ var28 := (m.AncestorValue.Selection == syncbase.ValueSelectionLocal)
+ var23 = var23 && var28
+ if var23 {
+ if err := fieldTarget22.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.AncestorValue.FillVDLTarget(fieldTarget22, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget21, fieldTarget22); err != nil {
return err
}
}
- keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("BatchIds")
+ keyTarget29, fieldTarget30, err := fieldsTarget1.StartField("BatchIds")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget12, err := fieldTarget11.StartList(tt.NonOptional().Field(4).Type, len(m.BatchIds))
- if err != nil {
- return err
+ var var31 bool
+ if len(m.BatchIds) == 0 {
+ var31 = true
}
- for i, elem14 := range m.BatchIds {
- elemTarget13, err := listTarget12.StartElem(i)
+ if var31 {
+ if err := fieldTarget30.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget32, err := fieldTarget30.StartList(tt.NonOptional().Field(4).Type, len(m.BatchIds))
if err != nil {
return err
}
- if err := elemTarget13.FromUint(uint64(elem14), tt.NonOptional().Field(4).Type.Elem()); err != nil {
- return err
+ for i, elem34 := range m.BatchIds {
+ elemTarget33, err := listTarget32.StartElem(i)
+ if err != nil {
+ return err
+ }
+ if err := elemTarget33.FromUint(uint64(elem34), tt.NonOptional().Field(4).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget32.FinishElem(elemTarget33); err != nil {
+ return err
+ }
}
- if err := listTarget12.FinishElem(elemTarget13); err != nil {
+ if err := fieldTarget30.FinishList(listTarget32); err != nil {
return err
}
}
- if err := fieldTarget11.FinishList(listTarget12); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget29, fieldTarget30); err != nil {
return err
}
}
@@ -329,6 +457,10 @@
return nil
}
+func (t *ConflictRowTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ConflictRow{}
+ return nil
+}
// []uint64
type __VDLTarget1_list struct {
@@ -362,6 +494,10 @@
return nil
}
+func (t *__VDLTarget1_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []uint64(nil)
+ return nil
+}
// ConflictRowSet contains a set of rows under conflict. It provides two different
// ways to access the same set.
@@ -383,95 +519,116 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("ByKey")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget4, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.ByKey))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.ByKey) == 0 {
+ var4 = true
}
- for key6, value8 := range m.ByKey {
- keyTarget5, err := mapTarget4.StartKey()
- if err != nil {
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
return err
}
- if err := keyTarget5.FromString(string(key6), tt.NonOptional().Field(0).Type.Key()); err != nil {
- return err
- }
- valueTarget7, err := mapTarget4.FinishKeyStartField(keyTarget5)
- if err != nil {
- return err
- }
+ } else {
- if err := value8.FillVDLTarget(valueTarget7, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ mapTarget5, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.ByKey))
+ if err != nil {
return err
}
- if err := mapTarget4.FinishField(keyTarget5, valueTarget7); err != nil {
+ for key7, value9 := range m.ByKey {
+ keyTarget6, err := mapTarget5.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget6.FromString(string(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget8, err := mapTarget5.FinishKeyStartField(keyTarget6)
+ if err != nil {
+ return err
+ }
+
+ if err := value9.FillVDLTarget(valueTarget8, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget5.FinishField(keyTarget6, valueTarget8); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishMap(mapTarget5); err != nil {
return err
}
}
- if err := fieldTarget3.FinishMap(mapTarget4); err != nil {
- return err
- }
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("ByBatch")
+ keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("ByBatch")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget11, err := fieldTarget10.StartMap(tt.NonOptional().Field(1).Type, len(m.ByBatch))
- if err != nil {
- return err
+ var var12 bool
+ if len(m.ByBatch) == 0 {
+ var12 = true
}
- for key13, value15 := range m.ByBatch {
- keyTarget12, err := mapTarget11.StartKey()
- if err != nil {
+ if var12 {
+ if err := fieldTarget11.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
- if err := keyTarget12.FromUint(uint64(key13), tt.NonOptional().Field(1).Type.Key()); err != nil {
- return err
- }
- valueTarget14, err := mapTarget11.FinishKeyStartField(keyTarget12)
- if err != nil {
- return err
- }
+ } else {
- listTarget16, err := valueTarget14.StartList(tt.NonOptional().Field(1).Type.Elem(), len(value15))
+ mapTarget13, err := fieldTarget11.StartMap(tt.NonOptional().Field(1).Type, len(m.ByBatch))
if err != nil {
return err
}
- for i, elem18 := range value15 {
- elemTarget17, err := listTarget16.StartElem(i)
+ for key15, value17 := range m.ByBatch {
+ keyTarget14, err := mapTarget13.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget14.FromUint(uint64(key15), tt.NonOptional().Field(1).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget16, err := mapTarget13.FinishKeyStartField(keyTarget14)
if err != nil {
return err
}
- if err := elem18.FillVDLTarget(elemTarget17, tt.NonOptional().Field(1).Type.Elem().Elem()); err != nil {
+ listTarget18, err := valueTarget16.StartList(tt.NonOptional().Field(1).Type.Elem(), len(value17))
+ if err != nil {
return err
}
- if err := listTarget16.FinishElem(elemTarget17); err != nil {
+ for i, elem20 := range value17 {
+ elemTarget19, err := listTarget18.StartElem(i)
+ if err != nil {
+ return err
+ }
+
+ if err := elem20.FillVDLTarget(elemTarget19, tt.NonOptional().Field(1).Type.Elem().Elem()); err != nil {
+ return err
+ }
+ if err := listTarget18.FinishElem(elemTarget19); err != nil {
+ return err
+ }
+ }
+ if err := valueTarget16.FinishList(listTarget18); err != nil {
+ return err
+ }
+ if err := mapTarget13.FinishField(keyTarget14, valueTarget16); err != nil {
return err
}
}
- if err := valueTarget14.FinishList(listTarget16); err != nil {
- return err
- }
- if err := mapTarget11.FinishField(keyTarget12, valueTarget14); err != nil {
+ if err := fieldTarget11.FinishMap(mapTarget13); err != nil {
return err
}
}
- if err := fieldTarget10.FinishMap(mapTarget11); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
return err
}
}
@@ -521,6 +678,10 @@
return nil
}
+func (t *ConflictRowSetTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ConflictRowSet{}
+ return nil
+}
// map[string]ConflictRow
type __VDLTarget2_map struct {
@@ -564,6 +725,10 @@
return nil
}
+func (t *__VDLTarget2_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[string]ConflictRow(nil)
+ return nil
+}
// map[uint64][]ConflictRow
type __VDLTarget3_map struct {
@@ -607,6 +772,10 @@
return nil
}
+func (t *__VDLTarget3_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[uint64][]ConflictRow(nil)
+ return nil
+}
// []ConflictRow
type __VDLTarget4_list struct {
@@ -640,6 +809,10 @@
return nil
}
+func (t *__VDLTarget4_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []ConflictRow(nil)
+ return nil
+}
// ConflictScanSet contains a set of scans under conflict.
// ByBatch is a map of array of ScanOps keyed by batch id.
@@ -657,56 +830,66 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("ByBatch")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget4, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.ByBatch))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.ByBatch) == 0 {
+ var4 = true
}
- for key6, value8 := range m.ByBatch {
- keyTarget5, err := mapTarget4.StartKey()
- if err != nil {
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
return err
}
- if err := keyTarget5.FromUint(uint64(key6), tt.NonOptional().Field(0).Type.Key()); err != nil {
- return err
- }
- valueTarget7, err := mapTarget4.FinishKeyStartField(keyTarget5)
- if err != nil {
- return err
- }
+ } else {
- listTarget9, err := valueTarget7.StartList(tt.NonOptional().Field(0).Type.Elem(), len(value8))
+ mapTarget5, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.ByBatch))
if err != nil {
return err
}
- for i, elem11 := range value8 {
- elemTarget10, err := listTarget9.StartElem(i)
+ for key7, value9 := range m.ByBatch {
+ keyTarget6, err := mapTarget5.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget6.FromUint(uint64(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget8, err := mapTarget5.FinishKeyStartField(keyTarget6)
if err != nil {
return err
}
- if err := elem11.FillVDLTarget(elemTarget10, tt.NonOptional().Field(0).Type.Elem().Elem()); err != nil {
+ listTarget10, err := valueTarget8.StartList(tt.NonOptional().Field(0).Type.Elem(), len(value9))
+ if err != nil {
return err
}
- if err := listTarget9.FinishElem(elemTarget10); err != nil {
+ for i, elem12 := range value9 {
+ elemTarget11, err := listTarget10.StartElem(i)
+ if err != nil {
+ return err
+ }
+
+ if err := elem12.FillVDLTarget(elemTarget11, tt.NonOptional().Field(0).Type.Elem().Elem()); err != nil {
+ return err
+ }
+ if err := listTarget10.FinishElem(elemTarget11); err != nil {
+ return err
+ }
+ }
+ if err := valueTarget8.FinishList(listTarget10); err != nil {
+ return err
+ }
+ if err := mapTarget5.FinishField(keyTarget6, valueTarget8); err != nil {
return err
}
}
- if err := valueTarget7.FinishList(listTarget9); err != nil {
+ if err := fieldTarget3.FinishMap(mapTarget5); err != nil {
return err
}
- if err := mapTarget4.FinishField(keyTarget5, valueTarget7); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishMap(mapTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -753,6 +936,10 @@
return nil
}
+func (t *ConflictScanSetTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ConflictScanSet{}
+ return nil
+}
// map[uint64][]syncbase.ScanOp
type __VDLTarget5_map struct {
@@ -796,6 +983,10 @@
return nil
}
+func (t *__VDLTarget5_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[uint64][]syncbase.ScanOp(nil)
+ return nil
+}
// []syncbase.ScanOp
type __VDLTarget6_list struct {
@@ -829,6 +1020,10 @@
return nil
}
+func (t *__VDLTarget6_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []syncbase.ScanOp(nil)
+ return nil
+}
// Conflict contains information to fully specify a conflict. Since syncbase
// supports batches there can be one or more rows within the batch that has a
@@ -861,18 +1056,19 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("ReadSet")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.ReadSet == nil {
- if err := fieldTarget3.FromNil(tt.NonOptional().Field(0).Type); err != nil {
+ var4 := (m.ReadSet == (*ConflictRowSet)(nil))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
return err
}
} else {
+
if err := m.ReadSet.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
return err
}
@@ -881,81 +1077,96 @@
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("WriteSet")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("WriteSet")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.WriteSet == nil {
- if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
+ var7 := (m.WriteSet == (*ConflictRowSet)(nil))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- if err := m.WriteSet.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
+
+ if err := m.WriteSet.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
return err
}
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("ScanSet")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("ScanSet")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.ScanSet == nil {
- if err := fieldTarget7.FromNil(tt.NonOptional().Field(2).Type); err != nil {
+ var10 := (m.ScanSet == (*ConflictScanSet)(nil))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
return err
}
} else {
- if err := m.ScanSet.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Batches")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- mapTarget10, err := fieldTarget9.StartMap(tt.NonOptional().Field(3).Type, len(m.Batches))
- if err != nil {
- return err
- }
- for key12, value14 := range m.Batches {
- keyTarget11, err := mapTarget10.StartKey()
- if err != nil {
+ if err := m.ScanSet.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
return err
}
- if err := keyTarget11.FromUint(uint64(key12), tt.NonOptional().Field(3).Type.Key()); err != nil {
- return err
- }
- valueTarget13, err := mapTarget10.FinishKeyStartField(keyTarget11)
- if err != nil {
- return err
- }
-
- if err := value14.FillVDLTarget(valueTarget13, tt.NonOptional().Field(3).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget10.FinishField(keyTarget11, valueTarget13); err != nil {
- return err
- }
- }
- if err := fieldTarget9.FinishMap(mapTarget10); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Batches")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var13 bool
+ if len(m.Batches) == 0 {
+ var13 = true
+ }
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget14, err := fieldTarget12.StartMap(tt.NonOptional().Field(3).Type, len(m.Batches))
+ if err != nil {
+ return err
+ }
+ for key16, value18 := range m.Batches {
+ keyTarget15, err := mapTarget14.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget15.FromUint(uint64(key16), tt.NonOptional().Field(3).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget17, err := mapTarget14.FinishKeyStartField(keyTarget15)
+ if err != nil {
+ return err
+ }
+
+ if err := value18.FillVDLTarget(valueTarget17, tt.NonOptional().Field(3).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget14.FinishField(keyTarget15, valueTarget17); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget12.FinishMap(mapTarget14); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -1012,6 +1223,10 @@
return nil
}
+func (t *ConflictTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Conflict{}
+ return nil
+}
// Optional ConflictRowSet
type __VDLTarget7_optional struct {
@@ -1037,10 +1252,8 @@
return nil
}
-func (t *__VDLTarget7_optional) FromNil(tt *vdl.Type) error {
-
- *t.Value = nil
-
+func (t *__VDLTarget7_optional) FromZero(tt *vdl.Type) error {
+ *t.Value = (*ConflictRowSet)(nil)
return nil
}
@@ -1068,10 +1281,8 @@
return nil
}
-func (t *__VDLTarget8_optional) FromNil(tt *vdl.Type) error {
-
- *t.Value = nil
-
+func (t *__VDLTarget8_optional) FromZero(tt *vdl.Type) error {
+ *t.Value = (*ConflictScanSet)(nil)
return nil
}
@@ -1117,6 +1328,10 @@
return nil
}
+func (t *__VDLTarget9_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[uint64]syncbase.BatchInfo(nil)
+ return nil
+}
// ResolvedRow represents a result of resolution of a row under conflict.
// Key is the key for the row.
@@ -1137,35 +1352,44 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Key == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Result")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Result")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.Result == nil {
- if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
+ var7 := (m.Result == (*Value)(nil))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- if err := m.Result.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
+
+ if err := m.Result.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
return err
}
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1215,6 +1439,10 @@
return nil
}
+func (t *ResolvedRowTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ResolvedRow{}
+ return nil
+}
// Optional Value
type __VDLTarget10_optional struct {
@@ -1240,10 +1468,8 @@
return nil
}
-func (t *__VDLTarget10_optional) FromNil(tt *vdl.Type) error {
-
- *t.Value = nil
-
+func (t *__VDLTarget10_optional) FromZero(tt *vdl.Type) error {
+ *t.Value = (*Value)(nil)
return nil
}
@@ -1265,40 +1491,50 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("ResultSet")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget4, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.ResultSet))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.ResultSet) == 0 {
+ var4 = true
}
- for key6, value8 := range m.ResultSet {
- keyTarget5, err := mapTarget4.StartKey()
- if err != nil {
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
return err
}
- if err := keyTarget5.FromString(string(key6), tt.NonOptional().Field(0).Type.Key()); err != nil {
- return err
- }
- valueTarget7, err := mapTarget4.FinishKeyStartField(keyTarget5)
- if err != nil {
- return err
- }
+ } else {
- if err := value8.FillVDLTarget(valueTarget7, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ mapTarget5, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.ResultSet))
+ if err != nil {
return err
}
- if err := mapTarget4.FinishField(keyTarget5, valueTarget7); err != nil {
+ for key7, value9 := range m.ResultSet {
+ keyTarget6, err := mapTarget5.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget6.FromString(string(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget8, err := mapTarget5.FinishKeyStartField(keyTarget6)
+ if err != nil {
+ return err
+ }
+
+ if err := value9.FillVDLTarget(valueTarget8, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget5.FinishField(keyTarget6, valueTarget8); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishMap(mapTarget5); err != nil {
return err
}
}
- if err := fieldTarget3.FinishMap(mapTarget4); err != nil {
- return err
- }
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
@@ -1344,6 +1580,10 @@
return nil
}
+func (t *ResolutionTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Resolution{}
+ return nil
+}
// map[string]ResolvedRow
type __VDLTarget11_map struct {
@@ -1387,17 +1627,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroValue = Value{}
- __VDLZeroConflictRow = ConflictRow{}
- __VDLZeroConflictRowSet = ConflictRowSet{}
- __VDLZeroConflictScanSet = ConflictScanSet{}
- __VDLZeroConflict = Conflict{}
- __VDLZeroResolvedRow = ResolvedRow{}
- __VDLZeroResolution = Resolution{}
-)
+func (t *__VDLTarget11_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[string]ResolvedRow(nil)
+ return nil
+}
var __VDLInitCalled bool
@@ -1418,6 +1651,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*Value)(nil))
diff --git a/syncbase/testdata/testdata.vdl.go b/syncbase/testdata/testdata.vdl.go
index 23e532c..ce28c19 100644
--- a/syncbase/testdata/testdata.vdl.go
+++ b/syncbase/testdata/testdata.vdl.go
@@ -36,55 +36,86 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Street")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Street), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Street == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Street), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("City")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("City")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.City), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.City == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.City), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("State")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("State")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromString(string(m.State), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Zip")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget9.FromString(string(m.Zip), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var10 := (m.State == "")
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromString(string(m.State), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Zip")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var13 := (m.Zip == "")
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget12.FromString(string(m.Zip), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -141,6 +172,10 @@
return nil
}
+func (t *AddressInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = AddressInfo{}
+ return nil
+}
type CreditAgency int
@@ -224,11 +259,15 @@
case "TransUnion":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum v.io/v23/syncbase/testdata.CreditAgency", src)
+ return fmt.Errorf("label %s not in enum CreditAgency", src)
}
return nil
}
+func (t *CreditAgencyTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = CreditAgencyEquifax
+ return nil
+}
type ExperianRating int
@@ -304,11 +343,15 @@
case "Bad":
*t.Value = 1
default:
- return fmt.Errorf("label %s not in enum v.io/v23/syncbase/testdata.ExperianRating", src)
+ return fmt.Errorf("label %s not in enum ExperianRating", src)
}
return nil
}
+func (t *ExperianRatingTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ExperianRatingGood
+ return nil
+}
type EquifaxCreditReport struct {
Rating byte
@@ -324,14 +367,21 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromUint(uint64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Rating == byte(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromUint(uint64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -378,6 +428,10 @@
return nil
}
+func (t *EquifaxCreditReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = EquifaxCreditReport{}
+ return nil
+}
type ExperianCreditReport struct {
Rating ExperianRating
@@ -393,15 +447,22 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Rating.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Rating == ExperianRatingGood)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Rating.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -448,6 +509,10 @@
return nil
}
+func (t *ExperianCreditReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ExperianCreditReport{}
+ return nil
+}
type TransUnionCreditReport struct {
Rating int16
@@ -463,14 +528,21 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromInt(int64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Rating == int16(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromInt(int64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -517,6 +589,10 @@
return nil
}
+func (t *TransUnionCreditReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = TransUnionCreditReport{}
+ return nil
+}
type (
// AgencyReport represents any single field of the AgencyReport union type.
@@ -692,6 +768,10 @@
return nil
}
+func (t *AgencyReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = AgencyReport(AgencyReportEquifaxReport{})
+ return nil
+}
type agencyReportTargetFactory struct{}
@@ -717,34 +797,54 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Agency")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Agency.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Agency == CreditAgencyEquifax)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Agency.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Report")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Report")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- unionValue6 := m.Report
- if unionValue6 == nil {
- unionValue6 = AgencyReportEquifaxReport{}
+ var var7 bool
+ if field, ok := m.Report.(AgencyReportEquifaxReport); ok {
+
+ var8 := (field.Value == EquifaxCreditReport{})
+ var7 = var8
}
- if err := unionValue6.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ unionValue9 := m.Report
+ if unionValue9 == nil {
+ unionValue9 = AgencyReportEquifaxReport{}
+ }
+ if err := unionValue9.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -794,6 +894,12 @@
return nil
}
+func (t *CreditReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = CreditReport{
+ Report: AgencyReportEquifaxReport{},
+ }
+ return nil
+}
type Customer struct {
Name string
@@ -813,66 +919,107 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Id")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromInt(int64(m.Id), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Active")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromBool(bool(m.Active), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Address")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Id")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Address.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
+ var7 := (m.Id == int64(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromInt(int64(m.Id), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Active")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var10 := (m.Active == false)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromBool(bool(m.Active), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("Credit")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Address")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Credit.FillVDLTarget(fieldTarget11, tt.NonOptional().Field(4).Type); err != nil {
+ var13 := (m.Address == AddressInfo{})
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Address.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
+ }
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Credit")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var16 := (m.Credit == CreditReport{
+ Report: AgencyReportEquifaxReport{},
+ })
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Credit.FillVDLTarget(fieldTarget15, tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
@@ -937,6 +1084,14 @@
return nil
}
+func (t *CustomerTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Customer{
+ Credit: CreditReport{
+ Report: AgencyReportEquifaxReport{},
+ },
+ }
+ return nil
+}
type Invoice struct {
CustId int64
@@ -956,71 +1111,110 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("CustId")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromInt(int64(m.CustId), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.CustId == int64(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromInt(int64(m.CustId), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("InvoiceNum")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromInt(int64(m.InvoiceNum), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- var wireValue6 time_2.Time
- if err := time_2.TimeFromNative(&wireValue6, m.InvoiceDate); err != nil {
- return err
- }
-
- keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("InvoiceDate")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("InvoiceNum")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue6.FillVDLTarget(fieldTarget8, tt.NonOptional().Field(2).Type); err != nil {
- return err
+ var7 := (m.InvoiceNum == int64(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromInt(int64(m.InvoiceNum), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Amount")
+ var wireValue8 time_2.Time
+ if err := time_2.TimeFromNative(&wireValue8, m.InvoiceDate); err != nil {
+ return err
+ }
+
+ keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("InvoiceDate")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget10.FromInt(int64(m.Amount), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var11 := (wireValue8 == time_2.Time{})
+ if var11 {
+ if err := fieldTarget10.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue8.FillVDLTarget(fieldTarget10, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
return err
}
}
- keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("ShipTo")
+ keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("Amount")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.ShipTo.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(4).Type); err != nil {
+ var14 := (m.Amount == int64(0))
+ if var14 {
+ if err := fieldTarget13.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget13.FromInt(int64(m.Amount), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ }
+ keyTarget15, fieldTarget16, err := fieldsTarget1.StartField("ShipTo")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var17 := (m.ShipTo == AddressInfo{})
+ if var17 {
+ if err := fieldTarget16.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.ShipTo.FillVDLTarget(fieldTarget16, tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget15, fieldTarget16); err != nil {
return err
}
}
@@ -1085,6 +1279,10 @@
return nil
}
+func (t *InvoiceTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Invoice{}
+ return nil
+}
type Numbers struct {
B byte
@@ -1108,112 +1306,183 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromUint(uint64(m.B), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.B == byte(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromUint(uint64(m.B), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Ui16")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Ui16")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromUint(uint64(m.Ui16), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Ui16 == uint16(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromUint(uint64(m.Ui16), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Ui32")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Ui32")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromUint(uint64(m.Ui32), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Ui64")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget9.FromUint(uint64(m.Ui64), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var10 := (m.Ui32 == uint32(0))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromUint(uint64(m.Ui32), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("I16")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Ui64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget11.FromInt(int64(m.I16), tt.NonOptional().Field(4).Type); err != nil {
- return err
+
+ var13 := (m.Ui64 == uint64(0))
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget12.FromUint(uint64(m.Ui64), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
- keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("I32")
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("I16")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget13.FromInt(int64(m.I32), tt.NonOptional().Field(5).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
- return err
- }
- }
- keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("I64")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget15.FromInt(int64(m.I64), tt.NonOptional().Field(6).Type); err != nil {
- return err
+
+ var16 := (m.I16 == int16(0))
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget15.FromInt(int64(m.I16), tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
- keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("F32")
+ keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("I32")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget17.FromFloat(float64(m.F32), tt.NonOptional().Field(7).Type); err != nil {
- return err
+
+ var19 := (m.I32 == int32(0))
+ if var19 {
+ if err := fieldTarget18.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget18.FromInt(int64(m.I32), tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
return err
}
}
- keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("F64")
+ keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("I64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget19.FromFloat(float64(m.F64), tt.NonOptional().Field(8).Type); err != nil {
+
+ var22 := (m.I64 == int64(0))
+ if var22 {
+ if err := fieldTarget21.FromZero(tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget21.FromInt(int64(m.I64), tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil {
+ }
+ keyTarget23, fieldTarget24, err := fieldsTarget1.StartField("F32")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var25 := (m.F32 == float32(0))
+ if var25 {
+ if err := fieldTarget24.FromZero(tt.NonOptional().Field(7).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget24.FromFloat(float64(m.F32), tt.NonOptional().Field(7).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget23, fieldTarget24); err != nil {
+ return err
+ }
+ }
+ keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("F64")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var28 := (m.F64 == float64(0))
+ if var28 {
+ if err := fieldTarget27.FromZero(tt.NonOptional().Field(8).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget27.FromFloat(float64(m.F64), tt.NonOptional().Field(8).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
return err
}
}
@@ -1298,6 +1567,10 @@
return nil
}
+func (t *NumbersTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Numbers{}
+ return nil
+}
type (
// TitleOrValueType represents any single field of the TitleOrValueType union type.
@@ -1431,6 +1704,10 @@
return nil
}
+func (t *TitleOrValueTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = TitleOrValueType(TitleOrValueTypeTitle{})
+ return nil
+}
type titleOrValueTypeTargetFactory struct{}
@@ -1456,33 +1733,53 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("TitleOrValue")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("TitleOrValue")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- unionValue6 := m.TitleOrValue
- if unionValue6 == nil {
- unionValue6 = TitleOrValueTypeTitle{}
+ var var7 bool
+ if field, ok := m.TitleOrValue.(TitleOrValueTypeTitle); ok {
+
+ var8 := (field.Value == "")
+ var7 = var8
}
- if err := unionValue6.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ unionValue9 := m.TitleOrValue
+ if unionValue9 == nil {
+ unionValue9 = TitleOrValueTypeTitle{}
+ }
+ if err := unionValue9.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1532,6 +1829,12 @@
return nil
}
+func (t *BazTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BazType{
+ TitleOrValue: TitleOrValueTypeTitle{},
+ }
+ return nil
+}
type BarType struct {
Baz BazType
@@ -1547,15 +1850,24 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Baz")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Baz.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Baz == BazType{
+ TitleOrValue: TitleOrValueTypeTitle{},
+ })
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Baz.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -1602,6 +1914,14 @@
return nil
}
+func (t *BarTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BarType{
+ Baz: BazType{
+ TitleOrValue: TitleOrValueTypeTitle{},
+ },
+ }
+ return nil
+}
type FooType struct {
Bar BarType
@@ -1617,15 +1937,26 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Bar")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Bar.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Bar == BarType{
+ Baz: BazType{
+ TitleOrValue: TitleOrValueTypeTitle{},
+ },
+ })
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Bar.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -1672,6 +2003,16 @@
return nil
}
+func (t *FooTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = FooType{
+ Bar: BarType{
+ Baz: BazType{
+ TitleOrValue: TitleOrValueTypeTitle{},
+ },
+ },
+ }
+ return nil
+}
type ArrayOfFour [4]string
@@ -1734,6 +2075,10 @@
return nil
}
+func (t *ArrayOfFourTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ArrayOfFour{}
+ return nil
+}
type KeyIndexData struct {
A ArrayOfFour
@@ -1752,111 +2097,151 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.A.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.A == ArrayOfFour{})
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.A.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("L")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("L")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget6, err := fieldTarget5.StartList(tt.NonOptional().Field(1).Type, len(m.L))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.L) == 0 {
+ var7 = true
}
- for i, elem8 := range m.L {
- elemTarget7, err := listTarget6.StartElem(i)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.L))
if err != nil {
return err
}
- if err := elemTarget7.FromString(string(elem8), tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ for i, elem10 := range m.L {
+ elemTarget9, err := listTarget8.StartElem(i)
+ if err != nil {
+ return err
+ }
+ if err := elemTarget9.FromString(string(elem10), tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ return err
+ }
}
- if err := listTarget6.FinishElem(elemTarget7); err != nil {
+ if err := fieldTarget6.FinishList(listTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishList(listTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("M")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("M")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget11, err := fieldTarget10.StartMap(tt.NonOptional().Field(2).Type, len(m.M))
- if err != nil {
- return err
+ var var13 bool
+ if len(m.M) == 0 {
+ var13 = true
}
- for key13, value15 := range m.M {
- keyTarget12, err := mapTarget11.StartKey()
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget14, err := fieldTarget12.StartMap(tt.NonOptional().Field(2).Type, len(m.M))
if err != nil {
return err
}
- if err := keyTarget12.FromInt(int64(key13), tt.NonOptional().Field(2).Type.Key()); err != nil {
- return err
+ for key16, value18 := range m.M {
+ keyTarget15, err := mapTarget14.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget15.FromInt(int64(key16), tt.NonOptional().Field(2).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget17, err := mapTarget14.FinishKeyStartField(keyTarget15)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget17.FromString(string(value18), tt.NonOptional().Field(2).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget14.FinishField(keyTarget15, valueTarget17); err != nil {
+ return err
+ }
}
- valueTarget14, err := mapTarget11.FinishKeyStartField(keyTarget12)
- if err != nil {
- return err
- }
- if err := valueTarget14.FromString(string(value15), tt.NonOptional().Field(2).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget11.FinishField(keyTarget12, valueTarget14); err != nil {
+ if err := fieldTarget12.FinishMap(mapTarget14); err != nil {
return err
}
}
- if err := fieldTarget10.FinishMap(mapTarget11); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
- keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("S")
+ keyTarget19, fieldTarget20, err := fieldsTarget1.StartField("S")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget18, err := fieldTarget17.StartSet(tt.NonOptional().Field(3).Type, len(m.S))
- if err != nil {
- return err
+ var var21 bool
+ if len(m.S) == 0 {
+ var21 = true
}
- for key20 := range m.S {
- keyTarget19, err := setTarget18.StartKey()
+ if var21 {
+ if err := fieldTarget20.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget22, err := fieldTarget20.StartSet(tt.NonOptional().Field(3).Type, len(m.S))
if err != nil {
return err
}
- if err := keyTarget19.FromString(string(key20), tt.NonOptional().Field(3).Type.Key()); err != nil {
- return err
+ for key24 := range m.S {
+ keyTarget23, err := setTarget22.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget23.FromString(string(key24), tt.NonOptional().Field(3).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget22.FinishKey(keyTarget23); err != nil {
+ return err
+ }
}
- if err := setTarget18.FinishKey(keyTarget19); err != nil {
+ if err := fieldTarget20.FinishSet(setTarget22); err != nil {
return err
}
}
- if err := fieldTarget17.FinishSet(setTarget18); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget19, fieldTarget20); err != nil {
return err
}
}
@@ -1916,6 +2301,10 @@
return nil
}
+func (t *KeyIndexDataTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = KeyIndexData{}
+ return nil
+}
// map[int64]string
type __VDLTarget1_map struct {
@@ -1959,6 +2348,10 @@
return nil
}
+func (t *__VDLTarget1_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[int64]string(nil)
+ return nil
+}
// map[string]struct{}
type __VDLTarget2_set struct {
@@ -1994,6 +2387,10 @@
return nil
}
+func (t *__VDLTarget2_set) FromZero(tt *vdl.Type) error {
+ *t.Value = map[string]struct{}(nil)
+ return nil
+}
type BigData struct {
Key string // A dup of the key stored in the value.
@@ -2009,14 +2406,21 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Key == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Key), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -2063,46 +2467,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroAddressInfo = AddressInfo{}
- __VDLZeroCreditAgency = CreditAgencyEquifax
- __VDLZeroExperianRating = ExperianRatingGood
- __VDLZeroEquifaxCreditReport = EquifaxCreditReport{}
- __VDLZeroExperianCreditReport = ExperianCreditReport{}
- __VDLZeroTransUnionCreditReport = TransUnionCreditReport{}
- __VDLZeroAgencyReport = AgencyReport(AgencyReportEquifaxReport{})
- __VDLZeroCreditReport = CreditReport{
- Report: AgencyReportEquifaxReport{},
- }
- __VDLZeroCustomer = Customer{
- Credit: CreditReport{
- Report: AgencyReportEquifaxReport{},
- },
- }
- __VDLZeroInvoice = Invoice{}
- __VDLZeroNumbers = Numbers{}
- __VDLZeroTitleOrValueType = TitleOrValueType(TitleOrValueTypeTitle{})
- __VDLZeroBazType = BazType{
- TitleOrValue: TitleOrValueTypeTitle{},
- }
- __VDLZeroBarType = BarType{
- Baz: BazType{
- TitleOrValue: TitleOrValueTypeTitle{},
- },
- }
- __VDLZeroFooType = FooType{
- Bar: BarType{
- Baz: BazType{
- TitleOrValue: TitleOrValueTypeTitle{},
- },
- },
- }
- __VDLZeroArrayOfFour = ArrayOfFour{}
- __VDLZeroKeyIndexData = KeyIndexData{}
- __VDLZeroBigData = BigData{}
-)
+func (t *BigDataTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BigData{}
+ return nil
+}
var __VDLInitCalled bool
@@ -2123,6 +2491,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*AddressInfo)(nil))
diff --git a/uniqueid/.api b/uniqueid/.api
index 51d8686..c6102dd 100644
--- a/uniqueid/.api
+++ b/uniqueid/.api
@@ -4,6 +4,7 @@
pkg uniqueid, method (*Id) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg uniqueid, method (*Id) MakeVDLTarget() vdl.Target
pkg uniqueid, method (*IdTarget) FromBytes([]byte, *vdl.Type) error
+pkg uniqueid, method (*IdTarget) FromZero(*vdl.Type) error
pkg uniqueid, method (*RandomGenerator) NewID() (Id, error)
pkg uniqueid, method (Id) String() string
pkg uniqueid, type Id [16]byte
diff --git a/uniqueid/uniqueid.vdl.go b/uniqueid/uniqueid.vdl.go
index 4558bb8..7264d41 100644
--- a/uniqueid/uniqueid.vdl.go
+++ b/uniqueid/uniqueid.vdl.go
@@ -50,11 +50,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroId = Id{}
-)
+func (t *IdTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Id{}
+ return nil
+}
var __VDLInitCalled bool
@@ -75,6 +74,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*Id)(nil))
diff --git a/vdl/.api b/vdl/.api
index 80b81cf..1b15b2b 100644
--- a/vdl/.api
+++ b/vdl/.api
@@ -81,10 +81,10 @@
pkg vdl, method (*BoolTarget) FromEnumLabel(string, *Type) error
pkg vdl, method (*BoolTarget) FromFloat(float64, *Type) error
pkg vdl, method (*BoolTarget) FromInt(int64, *Type) error
-pkg vdl, method (*BoolTarget) FromNil(*Type) error
pkg vdl, method (*BoolTarget) FromString(string, *Type) error
pkg vdl, method (*BoolTarget) FromTypeObject(*Type) error
pkg vdl, method (*BoolTarget) FromUint(uint64, *Type) error
+pkg vdl, method (*BoolTarget) FromZero(*Type) error
pkg vdl, method (*BoolTarget) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*BoolTarget) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*BoolTarget) StartMap(*Type, int) (MapTarget, error)
@@ -99,10 +99,10 @@
pkg vdl, method (*ByteTarget) FromEnumLabel(string, *Type) error
pkg vdl, method (*ByteTarget) FromFloat(float64, *Type) error
pkg vdl, method (*ByteTarget) FromInt(int64, *Type) error
-pkg vdl, method (*ByteTarget) FromNil(*Type) error
pkg vdl, method (*ByteTarget) FromString(string, *Type) error
pkg vdl, method (*ByteTarget) FromTypeObject(*Type) error
pkg vdl, method (*ByteTarget) FromUint(uint64, *Type) error
+pkg vdl, method (*ByteTarget) FromZero(*Type) error
pkg vdl, method (*ByteTarget) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*ByteTarget) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*ByteTarget) StartMap(*Type, int) (MapTarget, error)
@@ -117,10 +117,10 @@
pkg vdl, method (*BytesTarget) FromEnumLabel(string, *Type) error
pkg vdl, method (*BytesTarget) FromFloat(float64, *Type) error
pkg vdl, method (*BytesTarget) FromInt(int64, *Type) error
-pkg vdl, method (*BytesTarget) FromNil(*Type) error
pkg vdl, method (*BytesTarget) FromString(string, *Type) error
pkg vdl, method (*BytesTarget) FromTypeObject(*Type) error
pkg vdl, method (*BytesTarget) FromUint(uint64, *Type) error
+pkg vdl, method (*BytesTarget) FromZero(*Type) error
pkg vdl, method (*BytesTarget) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*BytesTarget) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*BytesTarget) StartMap(*Type, int) (MapTarget, error)
@@ -137,10 +137,10 @@
pkg vdl, method (*Float32Target) FromEnumLabel(string, *Type) error
pkg vdl, method (*Float32Target) FromFloat(float64, *Type) error
pkg vdl, method (*Float32Target) FromInt(int64, *Type) error
-pkg vdl, method (*Float32Target) FromNil(*Type) error
pkg vdl, method (*Float32Target) FromString(string, *Type) error
pkg vdl, method (*Float32Target) FromTypeObject(*Type) error
pkg vdl, method (*Float32Target) FromUint(uint64, *Type) error
+pkg vdl, method (*Float32Target) FromZero(*Type) error
pkg vdl, method (*Float32Target) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*Float32Target) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*Float32Target) StartMap(*Type, int) (MapTarget, error)
@@ -155,10 +155,10 @@
pkg vdl, method (*Float64Target) FromEnumLabel(string, *Type) error
pkg vdl, method (*Float64Target) FromFloat(float64, *Type) error
pkg vdl, method (*Float64Target) FromInt(int64, *Type) error
-pkg vdl, method (*Float64Target) FromNil(*Type) error
pkg vdl, method (*Float64Target) FromString(string, *Type) error
pkg vdl, method (*Float64Target) FromTypeObject(*Type) error
pkg vdl, method (*Float64Target) FromUint(uint64, *Type) error
+pkg vdl, method (*Float64Target) FromZero(*Type) error
pkg vdl, method (*Float64Target) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*Float64Target) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*Float64Target) StartMap(*Type, int) (MapTarget, error)
@@ -173,10 +173,10 @@
pkg vdl, method (*Int16Target) FromEnumLabel(string, *Type) error
pkg vdl, method (*Int16Target) FromFloat(float64, *Type) error
pkg vdl, method (*Int16Target) FromInt(int64, *Type) error
-pkg vdl, method (*Int16Target) FromNil(*Type) error
pkg vdl, method (*Int16Target) FromString(string, *Type) error
pkg vdl, method (*Int16Target) FromTypeObject(*Type) error
pkg vdl, method (*Int16Target) FromUint(uint64, *Type) error
+pkg vdl, method (*Int16Target) FromZero(*Type) error
pkg vdl, method (*Int16Target) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*Int16Target) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*Int16Target) StartMap(*Type, int) (MapTarget, error)
@@ -191,10 +191,10 @@
pkg vdl, method (*Int32Target) FromEnumLabel(string, *Type) error
pkg vdl, method (*Int32Target) FromFloat(float64, *Type) error
pkg vdl, method (*Int32Target) FromInt(int64, *Type) error
-pkg vdl, method (*Int32Target) FromNil(*Type) error
pkg vdl, method (*Int32Target) FromString(string, *Type) error
pkg vdl, method (*Int32Target) FromTypeObject(*Type) error
pkg vdl, method (*Int32Target) FromUint(uint64, *Type) error
+pkg vdl, method (*Int32Target) FromZero(*Type) error
pkg vdl, method (*Int32Target) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*Int32Target) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*Int32Target) StartMap(*Type, int) (MapTarget, error)
@@ -209,10 +209,10 @@
pkg vdl, method (*Int64Target) FromEnumLabel(string, *Type) error
pkg vdl, method (*Int64Target) FromFloat(float64, *Type) error
pkg vdl, method (*Int64Target) FromInt(int64, *Type) error
-pkg vdl, method (*Int64Target) FromNil(*Type) error
pkg vdl, method (*Int64Target) FromString(string, *Type) error
pkg vdl, method (*Int64Target) FromTypeObject(*Type) error
pkg vdl, method (*Int64Target) FromUint(uint64, *Type) error
+pkg vdl, method (*Int64Target) FromZero(*Type) error
pkg vdl, method (*Int64Target) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*Int64Target) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*Int64Target) StartMap(*Type, int) (MapTarget, error)
@@ -227,10 +227,10 @@
pkg vdl, method (*Int8Target) FromEnumLabel(string, *Type) error
pkg vdl, method (*Int8Target) FromFloat(float64, *Type) error
pkg vdl, method (*Int8Target) FromInt(int64, *Type) error
-pkg vdl, method (*Int8Target) FromNil(*Type) error
pkg vdl, method (*Int8Target) FromString(string, *Type) error
pkg vdl, method (*Int8Target) FromTypeObject(*Type) error
pkg vdl, method (*Int8Target) FromUint(uint64, *Type) error
+pkg vdl, method (*Int8Target) FromZero(*Type) error
pkg vdl, method (*Int8Target) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*Int8Target) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*Int8Target) StartMap(*Type, int) (MapTarget, error)
@@ -253,10 +253,10 @@
pkg vdl, method (*StringSliceTarget) FromEnumLabel(string, *Type) error
pkg vdl, method (*StringSliceTarget) FromFloat(float64, *Type) error
pkg vdl, method (*StringSliceTarget) FromInt(int64, *Type) error
-pkg vdl, method (*StringSliceTarget) FromNil(*Type) error
pkg vdl, method (*StringSliceTarget) FromString(string, *Type) error
pkg vdl, method (*StringSliceTarget) FromTypeObject(*Type) error
pkg vdl, method (*StringSliceTarget) FromUint(uint64, *Type) error
+pkg vdl, method (*StringSliceTarget) FromZero(*Type) error
pkg vdl, method (*StringSliceTarget) StartElem(int) (Target, error)
pkg vdl, method (*StringSliceTarget) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*StringSliceTarget) StartList(*Type, int) (ListTarget, error)
@@ -272,10 +272,10 @@
pkg vdl, method (*StringTarget) FromEnumLabel(string, *Type) error
pkg vdl, method (*StringTarget) FromFloat(float64, *Type) error
pkg vdl, method (*StringTarget) FromInt(int64, *Type) error
-pkg vdl, method (*StringTarget) FromNil(*Type) error
pkg vdl, method (*StringTarget) FromString(string, *Type) error
pkg vdl, method (*StringTarget) FromTypeObject(*Type) error
pkg vdl, method (*StringTarget) FromUint(uint64, *Type) error
+pkg vdl, method (*StringTarget) FromZero(*Type) error
pkg vdl, method (*StringTarget) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*StringTarget) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*StringTarget) StartMap(*Type, int) (MapTarget, error)
@@ -290,10 +290,10 @@
pkg vdl, method (*TargetBase) FromEnumLabel(string, *Type) error
pkg vdl, method (*TargetBase) FromFloat(float64, *Type) error
pkg vdl, method (*TargetBase) FromInt(int64, *Type) error
-pkg vdl, method (*TargetBase) FromNil(*Type) error
pkg vdl, method (*TargetBase) FromString(string, *Type) error
pkg vdl, method (*TargetBase) FromTypeObject(*Type) error
pkg vdl, method (*TargetBase) FromUint(uint64, *Type) error
+pkg vdl, method (*TargetBase) FromZero(*Type) error
pkg vdl, method (*TargetBase) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*TargetBase) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*TargetBase) StartMap(*Type, int) (MapTarget, error)
@@ -340,10 +340,10 @@
pkg vdl, method (*TypeObjectTarget) FromEnumLabel(string, *Type) error
pkg vdl, method (*TypeObjectTarget) FromFloat(float64, *Type) error
pkg vdl, method (*TypeObjectTarget) FromInt(int64, *Type) error
-pkg vdl, method (*TypeObjectTarget) FromNil(*Type) error
pkg vdl, method (*TypeObjectTarget) FromString(string, *Type) error
pkg vdl, method (*TypeObjectTarget) FromTypeObject(*Type) error
pkg vdl, method (*TypeObjectTarget) FromUint(uint64, *Type) error
+pkg vdl, method (*TypeObjectTarget) FromZero(*Type) error
pkg vdl, method (*TypeObjectTarget) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*TypeObjectTarget) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*TypeObjectTarget) StartMap(*Type, int) (MapTarget, error)
@@ -358,10 +358,10 @@
pkg vdl, method (*Uint16Target) FromEnumLabel(string, *Type) error
pkg vdl, method (*Uint16Target) FromFloat(float64, *Type) error
pkg vdl, method (*Uint16Target) FromInt(int64, *Type) error
-pkg vdl, method (*Uint16Target) FromNil(*Type) error
pkg vdl, method (*Uint16Target) FromString(string, *Type) error
pkg vdl, method (*Uint16Target) FromTypeObject(*Type) error
pkg vdl, method (*Uint16Target) FromUint(uint64, *Type) error
+pkg vdl, method (*Uint16Target) FromZero(*Type) error
pkg vdl, method (*Uint16Target) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*Uint16Target) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*Uint16Target) StartMap(*Type, int) (MapTarget, error)
@@ -376,10 +376,10 @@
pkg vdl, method (*Uint32Target) FromEnumLabel(string, *Type) error
pkg vdl, method (*Uint32Target) FromFloat(float64, *Type) error
pkg vdl, method (*Uint32Target) FromInt(int64, *Type) error
-pkg vdl, method (*Uint32Target) FromNil(*Type) error
pkg vdl, method (*Uint32Target) FromString(string, *Type) error
pkg vdl, method (*Uint32Target) FromTypeObject(*Type) error
pkg vdl, method (*Uint32Target) FromUint(uint64, *Type) error
+pkg vdl, method (*Uint32Target) FromZero(*Type) error
pkg vdl, method (*Uint32Target) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*Uint32Target) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*Uint32Target) StartMap(*Type, int) (MapTarget, error)
@@ -394,10 +394,10 @@
pkg vdl, method (*Uint64Target) FromEnumLabel(string, *Type) error
pkg vdl, method (*Uint64Target) FromFloat(float64, *Type) error
pkg vdl, method (*Uint64Target) FromInt(int64, *Type) error
-pkg vdl, method (*Uint64Target) FromNil(*Type) error
pkg vdl, method (*Uint64Target) FromString(string, *Type) error
pkg vdl, method (*Uint64Target) FromTypeObject(*Type) error
pkg vdl, method (*Uint64Target) FromUint(uint64, *Type) error
+pkg vdl, method (*Uint64Target) FromZero(*Type) error
pkg vdl, method (*Uint64Target) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*Uint64Target) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*Uint64Target) StartMap(*Type, int) (MapTarget, error)
@@ -455,10 +455,10 @@
pkg vdl, method (*WireErrorTarget) FromEnumLabel(string, *Type) error
pkg vdl, method (*WireErrorTarget) FromFloat(float64, *Type) error
pkg vdl, method (*WireErrorTarget) FromInt(int64, *Type) error
-pkg vdl, method (*WireErrorTarget) FromNil(*Type) error
pkg vdl, method (*WireErrorTarget) FromString(string, *Type) error
pkg vdl, method (*WireErrorTarget) FromTypeObject(*Type) error
pkg vdl, method (*WireErrorTarget) FromUint(uint64, *Type) error
+pkg vdl, method (*WireErrorTarget) FromZero(*Type) error
pkg vdl, method (*WireErrorTarget) StartField(string) (Target, Target, error)
pkg vdl, method (*WireErrorTarget) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*WireErrorTarget) StartList(*Type, int) (ListTarget, error)
@@ -477,10 +477,10 @@
pkg vdl, method (*WireRetryCodeTarget) FromEnumLabel(string, *Type) error
pkg vdl, method (*WireRetryCodeTarget) FromFloat(float64, *Type) error
pkg vdl, method (*WireRetryCodeTarget) FromInt(int64, *Type) error
-pkg vdl, method (*WireRetryCodeTarget) FromNil(*Type) error
pkg vdl, method (*WireRetryCodeTarget) FromString(string, *Type) error
pkg vdl, method (*WireRetryCodeTarget) FromTypeObject(*Type) error
pkg vdl, method (*WireRetryCodeTarget) FromUint(uint64, *Type) error
+pkg vdl, method (*WireRetryCodeTarget) FromZero(*Type) error
pkg vdl, method (*WireRetryCodeTarget) StartFields(*Type) (FieldsTarget, error)
pkg vdl, method (*WireRetryCodeTarget) StartList(*Type, int) (ListTarget, error)
pkg vdl, method (*WireRetryCodeTarget) StartMap(*Type, int) (MapTarget, error)
@@ -575,7 +575,7 @@
pkg vdl, type StringTarget struct
pkg vdl, type StringTarget struct, Value *string
pkg vdl, type StringTarget struct, embedded TargetBase
-pkg vdl, type Target interface { FinishFields, FinishList, FinishMap, FinishSet, FromBool, FromBytes, FromEnumLabel, FromFloat, FromInt, FromNil, FromString, FromTypeObject, FromUint, StartFields, StartList, StartMap, StartSet }
+pkg vdl, type Target interface { FinishFields, FinishList, FinishMap, FinishSet, FromBool, FromBytes, FromEnumLabel, FromFloat, FromInt, FromString, FromTypeObject, FromUint, FromZero, StartFields, StartList, StartMap, StartSet }
pkg vdl, type Target interface, FinishFields(FieldsTarget) error
pkg vdl, type Target interface, FinishList(ListTarget) error
pkg vdl, type Target interface, FinishMap(MapTarget) error
@@ -585,10 +585,10 @@
pkg vdl, type Target interface, FromEnumLabel(string, *Type) error
pkg vdl, type Target interface, FromFloat(float64, *Type) error
pkg vdl, type Target interface, FromInt(int64, *Type) error
-pkg vdl, type Target interface, FromNil(*Type) error
pkg vdl, type Target interface, FromString(string, *Type) error
pkg vdl, type Target interface, FromTypeObject(*Type) error
pkg vdl, type Target interface, FromUint(uint64, *Type) error
+pkg vdl, type Target interface, FromZero(*Type) error
pkg vdl, type Target interface, StartFields(*Type) (FieldsTarget, error)
pkg vdl, type Target interface, StartList(*Type, int) (ListTarget, error)
pkg vdl, type Target interface, StartMap(*Type, int) (MapTarget, error)
diff --git a/vdl/convert.go b/vdl/convert.go
index bf31d3c..97708c1 100644
--- a/vdl/convert.go
+++ b/vdl/convert.go
@@ -448,20 +448,99 @@
return nil
}
-// FromNil implements the Target interface method.
-func (c convTarget) FromNil(tt *Type) error {
- if c.tt == AnyType {
- // Optional is not currently supported for FromNil() direct targets
+// FromZero implements the Target interface method.
+func (c convTarget) FromZero(tt *Type) error {
+ if tt.Kind() != Optional {
+ // Optional is not currently supported for FromZero() direct targets
// because there is no way to get a generated optional struct target
// for an arbitrary struct. (the struct target itself doesn't support
- // the FromNil method).
+ // the FromZero method).
if target := c.makeDirectTarget(); target != nil {
- return target.FromNil(tt)
+ return target.FromZero(tt)
}
}
if !Compatible(c.tt, tt) {
return fmt.Errorf("types %q and %q aren't compatible", c.tt, tt)
}
+ switch tt.Kind() {
+ case Bool:
+ return c.FromBool(false, tt)
+ case Byte, Uint16, Uint32, Uint64:
+ return c.FromUint(0, tt)
+ case Int8, Int16, Int32, Int64:
+ return c.FromInt(0, tt)
+ case Float32, Float64:
+ return c.FromFloat(0, tt)
+ case String:
+ return c.FromString("", tt)
+ case Enum:
+ return c.FromEnumLabel(tt.EnumLabel(0), tt)
+ case TypeObject:
+ return c.FromTypeObject(AnyType)
+ case List, Array:
+ listTarget, err := c.StartList(tt, 0)
+ if err != nil {
+ return err
+ }
+ return c.FinishList(listTarget)
+ case Map:
+ mapTarget, err := c.StartMap(tt, 0)
+ if err != nil {
+ return err
+ }
+ return c.FinishMap(mapTarget)
+ case Set:
+ setTarget, err := c.StartSet(tt, 0)
+ if err != nil {
+ return err
+ }
+ return c.FinishSet(setTarget)
+ case Union:
+ fieldsTarget, err := c.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ defaultField := tt.Field(0)
+ keyTarget, fieldTarget, err := fieldsTarget.StartField(defaultField.Name)
+ if err != nil {
+ return err
+ }
+ if err := fieldTarget.FromZero(defaultField.Type); err != nil {
+ return err
+ }
+ if err := fieldsTarget.FinishField(keyTarget, fieldTarget); err != nil {
+ return err
+ }
+ return c.FinishFields(fieldsTarget)
+ case Struct:
+ fieldsTarget, err := c.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ for i := 0; i < tt.NumField(); i++ {
+ fld := tt.Field(i)
+ keyTarget, fieldTarget, err := fieldsTarget.StartField(fld.Name)
+ if err != ErrFieldNoExist {
+ if err != nil {
+ return err
+ }
+ if err := fieldTarget.FromZero(fld.Type); err != nil {
+ return err
+ }
+ if err := fieldsTarget.FinishField(keyTarget, fieldTarget); err != nil {
+ return err
+ }
+ }
+ }
+ return c.FinishFields(fieldsTarget)
+ case Any, Optional:
+ return c.fromNil(tt)
+ default:
+ return fmt.Errorf("unhandled kind: %v", tt.Kind())
+ }
+}
+
+func (c convTarget) fromNil(tt *Type) error {
if !tt.CanBeNil() || !c.tt.CanBeNil() {
return fmt.Errorf("invalid conversion from %v(nil) to %v", tt, c.tt)
}
@@ -495,14 +574,15 @@
// Set the zero value of the pointer or interface, which will give us nil of
// the correct type.
rv.Set(reflect.Zero(rt))
+ return nil
} else {
vvNil := ZeroValue(tt)
if to, from := c.vv.Type(), vvNil; !to.AssignableFrom(from) {
return fmt.Errorf("%v not assignable from %v", to, from)
}
c.vv.Assign(vvNil)
+ return nil
}
- return nil
}
// FromBool implements the Target interface method.
@@ -1167,21 +1247,22 @@
}
return reflectConv(rvField, ttField)
case reflect.Struct:
+ fieldName := key.rv.String()
if tt.Kind() == Union {
// Special-case: the fill target is a union concrete field struct. This
// means that we should only return a field if the field name matches.
- name := c.rv.Interface().(nameable).Name()
- if name != key.rv.String() {
+ existingName := c.rv.Interface().(nameable).Name()
+ if existingName != fieldName {
return convTarget{}, ErrFieldNoExist
}
- ttField, _ := tt.FieldByName(name)
+ ttField, _ := tt.FieldByName(fieldName)
return reflectConv(c.rv.FieldByName("Value"), ttField.Type)
}
// TODO(toddw): How should we handle anonymous (aka embedded) fields?
// Note that unexported embedded fields may themselves have exported
// fields. See https://github.com/golang/go/issues/12367
- rvField := c.rv.FieldByName(key.rv.String())
- ttField, index := tt.FieldByName(key.rv.String())
+ rvField := c.rv.FieldByName(fieldName)
+ ttField, index := tt.FieldByName(fieldName)
if !rvField.IsValid() || index < 0 {
// TODO(toddw): Add a way to track extra and missing fields.
return convTarget{}, ErrFieldNoExist
diff --git a/vdl/primitive_target.go b/vdl/primitive_target.go
index 0c24ec6..497d6fb 100644
--- a/vdl/primitive_target.go
+++ b/vdl/primitive_target.go
@@ -22,6 +22,13 @@
*t.Value = src
return nil
}
+func (t *BoolTarget) FromZero(tt *Type) error {
+ if !Compatible(tt, BoolType) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, BoolType)
+ }
+ *t.Value = false
+ return nil
+}
type ByteTarget struct {
Value *byte
@@ -49,6 +56,13 @@
*t.Value, err = vdlconv.Float64ToUint8(src)
return
}
+func (t *ByteTarget) FromZero(tt *Type) error {
+ if !Compatible(tt, ByteType) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, ByteType)
+ }
+ *t.Value = 0
+ return nil
+}
type Uint16Target struct {
Value *uint16
@@ -76,6 +90,13 @@
*t.Value, err = vdlconv.Float64ToUint16(src)
return
}
+func (t *Uint16Target) FromZero(tt *Type) error {
+ if !Compatible(tt, Uint16Type) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, Uint16Type)
+ }
+ *t.Value = 0
+ return nil
+}
type Uint32Target struct {
Value *uint32
@@ -103,6 +124,13 @@
*t.Value, err = vdlconv.Float64ToUint32(src)
return
}
+func (t *Uint32Target) FromZero(tt *Type) error {
+ if !Compatible(tt, Uint32Type) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, Uint32Type)
+ }
+ *t.Value = 0
+ return nil
+}
type Uint64Target struct {
Value *uint64
@@ -130,6 +158,13 @@
*t.Value, err = vdlconv.Float64ToUint64(src)
return
}
+func (t *Uint64Target) FromZero(tt *Type) error {
+ if !Compatible(tt, Uint64Type) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, Uint64Type)
+ }
+ *t.Value = 0
+ return nil
+}
type Int8Target struct {
Value *int8
@@ -157,6 +192,13 @@
*t.Value, err = vdlconv.Float64ToInt8(src)
return
}
+func (t *Int8Target) FromZero(tt *Type) error {
+ if !Compatible(tt, Int8Type) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, Int8Type)
+ }
+ *t.Value = 0
+ return nil
+}
type Int16Target struct {
Value *int16
@@ -184,6 +226,13 @@
*t.Value, err = vdlconv.Float64ToInt16(src)
return
}
+func (t *Int16Target) FromZero(tt *Type) error {
+ if !Compatible(tt, Int16Type) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, Int16Type)
+ }
+ *t.Value = 0
+ return nil
+}
type Int32Target struct {
Value *int32
@@ -211,6 +260,13 @@
*t.Value, err = vdlconv.Float64ToInt32(src)
return
}
+func (t *Int32Target) FromZero(tt *Type) error {
+ if !Compatible(tt, Int32Type) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, Int32Type)
+ }
+ *t.Value = 0
+ return nil
+}
type Int64Target struct {
Value *int64
@@ -238,6 +294,13 @@
*t.Value, err = vdlconv.Float64ToInt64(src)
return
}
+func (t *Int64Target) FromZero(tt *Type) error {
+ if !Compatible(tt, Int64Type) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, Int64Type)
+ }
+ *t.Value = 0
+ return nil
+}
type Float32Target struct {
Value *float32
@@ -265,6 +328,13 @@
*t.Value, err = vdlconv.Float64ToFloat32(src)
return
}
+func (t *Float32Target) FromZero(tt *Type) error {
+ if !Compatible(tt, Float32Type) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, Float32Type)
+ }
+ *t.Value = 0
+ return nil
+}
type Float64Target struct {
Value *float64
@@ -292,6 +362,13 @@
*t.Value = src
return
}
+func (t *Float64Target) FromZero(tt *Type) error {
+ if !Compatible(tt, Float64Type) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, Float64Type)
+ }
+ *t.Value = 0
+ return nil
+}
type StringTarget struct {
Value *string
@@ -305,6 +382,13 @@
*t.Value = src
return nil
}
+func (t *StringTarget) FromZero(tt *Type) error {
+ if !Compatible(tt, StringType) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, StringType)
+ }
+ *t.Value = ""
+ return nil
+}
type BytesTarget struct {
Value *[]byte
@@ -325,6 +409,13 @@
}
return nil
}
+func (t *BytesTarget) FromZero(tt *Type) error {
+ if !Compatible(tt, bytesType) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, bytesType)
+ }
+ *t.Value = nil
+ return nil
+}
type TypeObjectTarget struct {
Value **Type
@@ -335,6 +426,13 @@
*t.Value = tt
return nil
}
+func (t *TypeObjectTarget) FromZero(tt *Type) error {
+ if !Compatible(tt, TypeObjectType) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, TypeObjectType)
+ }
+ *t.Value = AnyType
+ return nil
+}
type StringSliceTarget struct {
Value *[]string
@@ -364,3 +462,10 @@
func (t *StringSliceTarget) FinishList(elem ListTarget) error {
return nil
}
+func (t *StringSliceTarget) FromZero(tt *Type) error {
+ if !Compatible(tt, stringSliceType) {
+ return fmt.Errorf("Type %v incompatible with expected type %v", tt, stringSliceType)
+ }
+ *t.Value = nil
+ return nil
+}
diff --git a/vdl/target.go b/vdl/target.go
index 2694b61..b7b6e16 100644
--- a/vdl/target.go
+++ b/vdl/target.go
@@ -39,9 +39,8 @@
FromEnumLabel(src string, tt *Type) error
// FromTypeObject converts from the src type to the target.
FromTypeObject(src *Type) error
- // FromNil converts from a nil (nonexistent) value of type tt, where tt must
- // be of kind Optional or Any.
- FromNil(tt *Type) error
+ // FromZero converts from a zero value of type tt.
+ FromZero(tt *Type) error
// StartList prepares conversion from a list or array of type tt, with the
// given len. FinishList must be called to finish the list.
@@ -175,7 +174,7 @@
func FromReflect(target Target, rv reflect.Value) error {
// Special-case to treat interface{}(nil) as any(nil).
if !rv.IsValid() {
- return target.FromNil(AnyType)
+ return target.FromZero(AnyType)
}
// Flatten pointers and interfaces in rv, and handle special-cases. We track
@@ -213,7 +212,7 @@
// Treat nil Union interface as the value of the type at index 0.
return FromValue(target, ZeroValue(tt))
}
- return target.FromNil(tt)
+ return target.FromZero(tt)
case rt.ConvertibleTo(rtPtrToType):
// If rv is convertible to *Type, fill from it directly.
return target.FromTypeObject(rv.Convert(rtPtrToType).Interface().(*Type))
@@ -441,18 +440,15 @@
// the appropriate methods on the target.
func FromValue(target Target, vv *Value) error {
tt := vv.Type()
+ if vv.IsZero() {
+ return target.FromZero(tt)
+ }
if tt.Kind() == Any {
- if vv.IsNil() {
- return target.FromNil(tt)
- }
// Non-nil any simply converts from the elem.
vv = vv.Elem()
tt = vv.Type()
}
if tt.Kind() == Optional {
- if vv.IsNil() {
- return target.FromNil(tt)
- }
// Non-nil optional is special - we keep tt as the optional type, but use
// the elem value for the actual value below.
vv = vv.Elem()
diff --git a/vdl/target_base.go b/vdl/target_base.go
index 99840e4..74cdcd3 100644
--- a/vdl/target_base.go
+++ b/vdl/target_base.go
@@ -18,7 +18,7 @@
errFromString = errors.New("method FromString invalid for this target type")
errFromEnumLabel = errors.New("method FromEnumLabel invalid for this target type")
errFromTypeObject = errors.New("method FromTypeObject invalid for this target type")
- errFromNil = errors.New("method FromNil invalid for this target type")
+ errFromZero = errors.New("method FromZero invalid for this target type")
errStartList = errors.New("method StartList invalid for this target type")
errFinishList = errors.New("method FinishList invalid for this target type")
errStartSet = errors.New("method StartSet invalid for this target type")
@@ -49,7 +49,7 @@
func (*TargetBase) FromString(_ string, _ *Type) error { return errFromString }
func (*TargetBase) FromEnumLabel(_ string, _ *Type) error { return errFromEnumLabel }
func (*TargetBase) FromTypeObject(_ *Type) error { return errFromTypeObject }
-func (*TargetBase) FromNil(_ *Type) error { return errFromNil }
+func (*TargetBase) FromZero(_ *Type) error { return errFromZero }
func (*TargetBase) StartList(_ *Type, _ int) (ListTarget, error) { return nil, errStartList }
func (*TargetBase) FinishList(_ ListTarget) error { return errFinishList }
func (*TargetBase) StartSet(_ *Type, _ int) (SetTarget, error) { return nil, errStartSet }
diff --git a/vdl/vdl.vdl.go b/vdl/vdl.vdl.go
index 4737f2e..38f5c64 100644
--- a/vdl/vdl.vdl.go
+++ b/vdl/vdl.vdl.go
@@ -110,11 +110,15 @@
case "RetryBackoff":
*t.Value = 3
default:
- return fmt.Errorf("label %s not in enum v.io/v23/vdl.WireRetryCode", src)
+ return fmt.Errorf("label %s not in enum WireRetryCode", src)
}
return nil
}
+func (t *WireRetryCodeTarget) FromZero(tt *Type) error {
+ *t.Value = WireRetryCodeNoRetry
+ return nil
+}
// WireError is the wire representation for the built-in error type. Errors and
// exceptions in each programming environment are converted to this type to
@@ -137,77 +141,111 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Id")
if err != ErrFieldNoExist && err != nil {
return err
}
if err != ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Id), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Id == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Id), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("RetryCode")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("RetryCode")
if err != ErrFieldNoExist && err != nil {
return err
}
if err != ErrFieldNoExist {
- if err := m.RetryCode.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.RetryCode == WireRetryCodeNoRetry)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.RetryCode.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Msg")
- if err != ErrFieldNoExist && err != nil {
- return err
- }
- if err != ErrFieldNoExist {
- if err := fieldTarget7.FromString(string(m.Msg), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("ParamList")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Msg")
if err != ErrFieldNoExist && err != nil {
return err
}
if err != ErrFieldNoExist {
- listTarget10, err := fieldTarget9.StartList(tt.NonOptional().Field(3).Type, len(m.ParamList))
- if err != nil {
+ var10 := (m.Msg == "")
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromString(string(m.Msg), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
- for i, elem12 := range m.ParamList {
- elemTarget11, err := listTarget10.StartElem(i)
+ }
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("ParamList")
+ if err != ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != ErrFieldNoExist {
+
+ var var13 bool
+ if len(m.ParamList) == 0 {
+ var13 = true
+ }
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget14, err := fieldTarget12.StartList(tt.NonOptional().Field(3).Type, len(m.ParamList))
if err != nil {
return err
}
-
- if elem12 == nil {
- if err := elemTarget11.FromNil(tt.NonOptional().Field(3).Type.Elem()); err != nil {
+ for i, elem16 := range m.ParamList {
+ elemTarget15, err := listTarget14.StartElem(i)
+ if err != nil {
return err
}
- } else {
- if err := FromValue(elemTarget11, elem12); err != nil {
+
+ if elem16 == nil {
+ if err := elemTarget15.FromZero(tt.NonOptional().Field(3).Type.Elem()); err != nil {
+ return err
+ }
+ } else {
+ if err := FromValue(elemTarget15, elem16); err != nil {
+ return err
+ }
+ }
+ if err := listTarget14.FinishElem(elemTarget15); err != nil {
return err
}
}
- if err := listTarget10.FinishElem(elemTarget11); err != nil {
+ if err := fieldTarget12.FinishList(listTarget14); err != nil {
return err
}
}
- if err := fieldTarget9.FinishList(listTarget10); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
@@ -267,6 +305,10 @@
return nil
}
+func (t *WireErrorTarget) FromZero(tt *Type) error {
+ *t.Value = WireError{}
+ return nil
+}
// []*Value
type __VDLTarget1_list struct {
@@ -299,12 +341,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroWireRetryCode = WireRetryCodeNoRetry
- __VDLZeroWireError = WireError{}
-)
+func (t *__VDLTarget1_list) FromZero(tt *Type) error {
+ *t.Value = []*Value(nil)
+ return nil
+}
var __VDLInitCalled bool
@@ -325,6 +365,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
Register((*WireRetryCode)(nil))
diff --git a/vdlroot/init.go b/vdlroot/init.go
index 2fbfff9..aa557a4 100644
--- a/vdlroot/init.go
+++ b/vdlroot/init.go
@@ -8,6 +8,9 @@
// This package contains import dependencies on all its sub-packages. This is
// meant as a convenient mechanism to pull in all standard vdl packages; import
// vdlroot to ensure the types for all standard vdl packages are registered.
+//
+// To regenerate the .vdl.go files, specify VDLROOT when invoking the vdl tool.
+// (by default, prebuilt copies of the packages will be used).
package vdlroot
import (
diff --git a/vdlroot/math/.api b/vdlroot/math/.api
index 28f5f93..e0cb880 100644
--- a/vdlroot/math/.api
+++ b/vdlroot/math/.api
@@ -6,12 +6,14 @@
pkg math, method (*Complex128) MakeVDLTarget() vdl.Target
pkg math, method (*Complex128Target) FinishField(vdl.Target, vdl.Target) error
pkg math, method (*Complex128Target) FinishFields(vdl.FieldsTarget) error
+pkg math, method (*Complex128Target) FromZero(*vdl.Type) error
pkg math, method (*Complex128Target) StartField(string) (vdl.Target, vdl.Target, error)
pkg math, method (*Complex128Target) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg math, method (*Complex64) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg math, method (*Complex64) MakeVDLTarget() vdl.Target
pkg math, method (*Complex64Target) FinishField(vdl.Target, vdl.Target) error
pkg math, method (*Complex64Target) FinishFields(vdl.FieldsTarget) error
+pkg math, method (*Complex64Target) FromZero(*vdl.Type) error
pkg math, method (*Complex64Target) StartField(string) (vdl.Target, vdl.Target, error)
pkg math, method (*Complex64Target) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg math, type Complex128 struct
diff --git a/vdlroot/math/math.vdl.go b/vdlroot/math/math.vdl.go
index 0cb3dbc..1c19c59 100644
--- a/vdlroot/math/math.vdl.go
+++ b/vdlroot/math/math.vdl.go
@@ -32,28 +32,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Real")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromFloat(float64(m.Real), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Real == float32(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromFloat(float64(m.Real), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Imag")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Imag")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromFloat(float64(m.Imag), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Imag == float32(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromFloat(float64(m.Imag), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -107,6 +122,16 @@
}
return nil
}
+func (t *Complex64Target) FromZero(tt *vdl.Type) error {
+ *t.Value = func() complex64 {
+ var native complex64
+ if err := vdl.Convert(&native, Complex64{}); err != nil {
+ panic(err)
+ }
+ return native
+ }()
+ return nil
+}
type Complex128 struct {
Real float64
@@ -123,28 +148,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Real")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromFloat(float64(m.Real), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Real == float64(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromFloat(float64(m.Real), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Imag")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Imag")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromFloat(float64(m.Imag), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Imag == float64(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromFloat(float64(m.Imag), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -198,24 +238,16 @@
}
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroComplex64 = func() complex64 {
- var native complex64
- if err := vdl.Convert(&native, Complex64{}); err != nil {
- panic(err)
- }
- return native
- }()
- __VDLZeroComplex128 = func() complex128 {
+func (t *Complex128Target) FromZero(tt *vdl.Type) error {
+ *t.Value = func() complex128 {
var native complex128
if err := vdl.Convert(&native, Complex128{}); err != nil {
panic(err)
}
return native
}()
-)
+ return nil
+}
// Type-check native conversion functions.
var (
@@ -244,6 +276,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register native type conversions first, so that vdl.TypeOf works.
vdl.RegisterNative(Complex128ToNative, Complex128FromNative)
diff --git a/vdlroot/signature/.api b/vdlroot/signature/.api
index 10fa35d..d16044c 100644
--- a/vdlroot/signature/.api
+++ b/vdlroot/signature/.api
@@ -11,12 +11,14 @@
pkg signature, method (*Arg) MakeVDLTarget() vdl.Target
pkg signature, method (*ArgTarget) FinishField(vdl.Target, vdl.Target) error
pkg signature, method (*ArgTarget) FinishFields(vdl.FieldsTarget) error
+pkg signature, method (*ArgTarget) FromZero(*vdl.Type) error
pkg signature, method (*ArgTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg signature, method (*ArgTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg signature, method (*Embed) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg signature, method (*Embed) MakeVDLTarget() vdl.Target
pkg signature, method (*EmbedTarget) FinishField(vdl.Target, vdl.Target) error
pkg signature, method (*EmbedTarget) FinishFields(vdl.FieldsTarget) error
+pkg signature, method (*EmbedTarget) FromZero(*vdl.Type) error
pkg signature, method (*EmbedTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg signature, method (*EmbedTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg signature, method (*Interface) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -24,12 +26,14 @@
pkg signature, method (*Interface) MakeVDLTarget() vdl.Target
pkg signature, method (*InterfaceTarget) FinishField(vdl.Target, vdl.Target) error
pkg signature, method (*InterfaceTarget) FinishFields(vdl.FieldsTarget) error
+pkg signature, method (*InterfaceTarget) FromZero(*vdl.Type) error
pkg signature, method (*InterfaceTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg signature, method (*InterfaceTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg signature, method (*Method) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg signature, method (*Method) MakeVDLTarget() vdl.Target
pkg signature, method (*MethodTarget) FinishField(vdl.Target, vdl.Target) error
pkg signature, method (*MethodTarget) FinishFields(vdl.FieldsTarget) error
+pkg signature, method (*MethodTarget) FromZero(*vdl.Type) error
pkg signature, method (*MethodTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg signature, method (*MethodTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg signature, method (SortableMethods) Len() int
diff --git a/vdlroot/signature/signature.vdl.go b/vdlroot/signature/signature.vdl.go
index 91fdbae..450680c 100644
--- a/vdlroot/signature/signature.vdl.go
+++ b/vdlroot/signature/signature.vdl.go
@@ -36,40 +36,63 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("PkgPath")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("PkgPath")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.PkgPath), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.PkgPath == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.PkgPath), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Doc")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Doc")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromString(string(m.Doc), tt.NonOptional().Field(2).Type); err != nil {
- return err
+
+ var10 := (m.Doc == "")
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromString(string(m.Doc), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -124,6 +147,10 @@
return nil
}
+func (t *EmbedTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Embed{}
+ return nil
+}
// Arg describes the signature of a single argument.
type Arg struct {
@@ -142,44 +169,67 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Doc")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Doc")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Doc), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Doc == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Doc), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Type")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Type")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- typeObjectVal8 := m.Type
- if typeObjectVal8 == nil {
- typeObjectVal8 = vdl.AnyType
+
+ var10 := (m.Type == vdl.AnyType)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ typeObjectVal11 := m.Type
+ if typeObjectVal11 == nil {
+ typeObjectVal11 = vdl.AnyType
+ }
+ if err := fieldTarget9.FromTypeObject(typeObjectVal11); err != nil {
+ return err
+ }
}
- if err := fieldTarget7.FromTypeObject(typeObjectVal8); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -234,6 +284,12 @@
return nil
}
+func (t *ArgTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Arg{
+ Type: vdl.AnyType,
+ }
+ return nil
+}
// Method describes the signature of an interface method.
type Method struct {
@@ -256,165 +312,217 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Doc")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Doc), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("InArgs")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Doc")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget8, err := fieldTarget7.StartList(tt.NonOptional().Field(2).Type, len(m.InArgs))
- if err != nil {
- return err
- }
- for i, elem10 := range m.InArgs {
- elemTarget9, err := listTarget8.StartElem(i)
- if err != nil {
- return err
- }
-
- if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(2).Type.Elem()); err != nil {
- return err
- }
- if err := listTarget8.FinishElem(elemTarget9); err != nil {
- return err
- }
- }
- if err := fieldTarget7.FinishList(listTarget8); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("OutArgs")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
-
- listTarget13, err := fieldTarget12.StartList(tt.NonOptional().Field(3).Type, len(m.OutArgs))
- if err != nil {
- return err
- }
- for i, elem15 := range m.OutArgs {
- elemTarget14, err := listTarget13.StartElem(i)
- if err != nil {
- return err
- }
-
- if err := elem15.FillVDLTarget(elemTarget14, tt.NonOptional().Field(3).Type.Elem()); err != nil {
- return err
- }
- if err := listTarget13.FinishElem(elemTarget14); err != nil {
- return err
- }
- }
- if err := fieldTarget12.FinishList(listTarget13); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
- return err
- }
- }
- keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("InStream")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
-
- if m.InStream == nil {
- if err := fieldTarget17.FromNil(tt.NonOptional().Field(4).Type); err != nil {
+ var7 := (m.Doc == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- if err := m.InStream.FillVDLTarget(fieldTarget17, tt.NonOptional().Field(4).Type); err != nil {
+ if err := fieldTarget6.FromString(string(m.Doc), tt.NonOptional().Field(1).Type); err != nil {
return err
}
}
- if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("OutStream")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("InArgs")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.OutStream == nil {
- if err := fieldTarget19.FromNil(tt.NonOptional().Field(5).Type); err != nil {
+ var var10 bool
+ if len(m.InArgs) == 0 {
+ var10 = true
+ }
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
return err
}
} else {
- if err := m.OutStream.FillVDLTarget(fieldTarget19, tt.NonOptional().Field(5).Type); err != nil {
+
+ listTarget11, err := fieldTarget9.StartList(tt.NonOptional().Field(2).Type, len(m.InArgs))
+ if err != nil {
+ return err
+ }
+ for i, elem13 := range m.InArgs {
+ elemTarget12, err := listTarget11.StartElem(i)
+ if err != nil {
+ return err
+ }
+
+ if err := elem13.FillVDLTarget(elemTarget12, tt.NonOptional().Field(2).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget11.FinishElem(elemTarget12); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget9.FinishList(listTarget11); err != nil {
return err
}
}
- if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("Tags")
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("OutArgs")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget22, err := fieldTarget21.StartList(tt.NonOptional().Field(6).Type, len(m.Tags))
- if err != nil {
- return err
+ var var16 bool
+ if len(m.OutArgs) == 0 {
+ var16 = true
}
- for i, elem24 := range m.Tags {
- elemTarget23, err := listTarget22.StartElem(i)
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget17, err := fieldTarget15.StartList(tt.NonOptional().Field(3).Type, len(m.OutArgs))
if err != nil {
return err
}
-
- if elem24 == nil {
- if err := elemTarget23.FromNil(tt.NonOptional().Field(6).Type.Elem()); err != nil {
+ for i, elem19 := range m.OutArgs {
+ elemTarget18, err := listTarget17.StartElem(i)
+ if err != nil {
return err
}
- } else {
- if err := vdl.FromValue(elemTarget23, elem24); err != nil {
+
+ if err := elem19.FillVDLTarget(elemTarget18, tt.NonOptional().Field(3).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget17.FinishElem(elemTarget18); err != nil {
return err
}
}
- if err := listTarget22.FinishElem(elemTarget23); err != nil {
+ if err := fieldTarget15.FinishList(listTarget17); err != nil {
return err
}
}
- if err := fieldTarget21.FinishList(listTarget22); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
+ }
+ keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("InStream")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var22 := (m.InStream == (*Arg)(nil))
+ if var22 {
+ if err := fieldTarget21.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.InStream.FillVDLTarget(fieldTarget21, tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ }
if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
return err
}
}
+ keyTarget23, fieldTarget24, err := fieldsTarget1.StartField("OutStream")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var25 := (m.OutStream == (*Arg)(nil))
+ if var25 {
+ if err := fieldTarget24.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.OutStream.FillVDLTarget(fieldTarget24, tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget23, fieldTarget24); err != nil {
+ return err
+ }
+ }
+ keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("Tags")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var28 bool
+ if len(m.Tags) == 0 {
+ var28 = true
+ }
+ if var28 {
+ if err := fieldTarget27.FromZero(tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget29, err := fieldTarget27.StartList(tt.NonOptional().Field(6).Type, len(m.Tags))
+ if err != nil {
+ return err
+ }
+ for i, elem31 := range m.Tags {
+ elemTarget30, err := listTarget29.StartElem(i)
+ if err != nil {
+ return err
+ }
+
+ if elem31 == nil {
+ if err := elemTarget30.FromZero(tt.NonOptional().Field(6).Type.Elem()); err != nil {
+ return err
+ }
+ } else {
+ if err := vdl.FromValue(elemTarget30, elem31); err != nil {
+ return err
+ }
+ }
+ if err := listTarget29.FinishElem(elemTarget30); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget27.FinishList(listTarget29); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -486,6 +594,10 @@
return nil
}
+func (t *MethodTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Method{}
+ return nil
+}
// []Arg
type __VDLTarget1_list struct {
@@ -519,6 +631,10 @@
return nil
}
+func (t *__VDLTarget1_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []Arg(nil)
+ return nil
+}
// Optional Arg
type __VDLTarget2_optional struct {
@@ -546,10 +662,8 @@
return nil
}
-func (t *__VDLTarget2_optional) FromNil(tt *vdl.Type) error {
-
- *t.Value = nil
-
+func (t *__VDLTarget2_optional) FromZero(tt *vdl.Type) error {
+ *t.Value = (*Arg)(nil)
return nil
}
@@ -584,6 +698,10 @@
return nil
}
+func (t *__VDLTarget3_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []*vdl.Value(nil)
+ return nil
+}
// Interface describes the signature of an interface.
type Interface struct {
@@ -604,100 +722,145 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("PkgPath")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.PkgPath), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Doc")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromString(string(m.Doc), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Embeds")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("PkgPath")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget10, err := fieldTarget9.StartList(tt.NonOptional().Field(3).Type, len(m.Embeds))
- if err != nil {
- return err
- }
- for i, elem12 := range m.Embeds {
- elemTarget11, err := listTarget10.StartElem(i)
- if err != nil {
+ var7 := (m.PkgPath == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
+ } else {
+ if err := fieldTarget6.FromString(string(m.PkgPath), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ return err
+ }
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Doc")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
- if err := elem12.FillVDLTarget(elemTarget11, tt.NonOptional().Field(3).Type.Elem()); err != nil {
+ var10 := (m.Doc == "")
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
return err
}
- if err := listTarget10.FinishElem(elemTarget11); err != nil {
+ } else {
+ if err := fieldTarget9.FromString(string(m.Doc), tt.NonOptional().Field(2).Type); err != nil {
return err
}
}
- if err := fieldTarget9.FinishList(listTarget10); err != nil {
- return err
- }
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget13, fieldTarget14, err := fieldsTarget1.StartField("Methods")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Embeds")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget15, err := fieldTarget14.StartList(tt.NonOptional().Field(4).Type, len(m.Methods))
- if err != nil {
- return err
+ var var13 bool
+ if len(m.Embeds) == 0 {
+ var13 = true
}
- for i, elem17 := range m.Methods {
- elemTarget16, err := listTarget15.StartElem(i)
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget14, err := fieldTarget12.StartList(tt.NonOptional().Field(3).Type, len(m.Embeds))
if err != nil {
return err
}
+ for i, elem16 := range m.Embeds {
+ elemTarget15, err := listTarget14.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem17.FillVDLTarget(elemTarget16, tt.NonOptional().Field(4).Type.Elem()); err != nil {
- return err
+ if err := elem16.FillVDLTarget(elemTarget15, tt.NonOptional().Field(3).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget14.FinishElem(elemTarget15); err != nil {
+ return err
+ }
}
- if err := listTarget15.FinishElem(elemTarget16); err != nil {
+ if err := fieldTarget12.FinishList(listTarget14); err != nil {
return err
}
}
- if err := fieldTarget14.FinishList(listTarget15); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget13, fieldTarget14); err != nil {
+ }
+ keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("Methods")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var19 bool
+ if len(m.Methods) == 0 {
+ var19 = true
+ }
+ if var19 {
+ if err := fieldTarget18.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget20, err := fieldTarget18.StartList(tt.NonOptional().Field(4).Type, len(m.Methods))
+ if err != nil {
+ return err
+ }
+ for i, elem22 := range m.Methods {
+ elemTarget21, err := listTarget20.StartElem(i)
+ if err != nil {
+ return err
+ }
+
+ if err := elem22.FillVDLTarget(elemTarget21, tt.NonOptional().Field(4).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget20.FinishElem(elemTarget21); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget18.FinishList(listTarget20); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
return err
}
}
@@ -762,6 +925,10 @@
return nil
}
+func (t *InterfaceTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Interface{}
+ return nil
+}
// []Embed
type __VDLTarget4_list struct {
@@ -795,6 +962,10 @@
return nil
}
+func (t *__VDLTarget4_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []Embed(nil)
+ return nil
+}
// []Method
type __VDLTarget5_list struct {
@@ -828,16 +999,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroEmbed = Embed{}
- __VDLZeroArg = Arg{
- Type: vdl.AnyType,
- }
- __VDLZeroMethod = Method{}
- __VDLZeroInterface = Interface{}
-)
+func (t *__VDLTarget5_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []Method(nil)
+ return nil
+}
var __VDLInitCalled bool
@@ -858,6 +1023,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*Embed)(nil))
diff --git a/vdlroot/time/.api b/vdlroot/time/.api
index 7f28419..290e852 100644
--- a/vdlroot/time/.api
+++ b/vdlroot/time/.api
@@ -9,18 +9,21 @@
pkg time, method (*Duration) MakeVDLTarget() vdl.Target
pkg time, method (*DurationTarget) FinishField(vdl.Target, vdl.Target) error
pkg time, method (*DurationTarget) FinishFields(vdl.FieldsTarget) error
+pkg time, method (*DurationTarget) FromZero(*vdl.Type) error
pkg time, method (*DurationTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg time, method (*DurationTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg time, method (*Time) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg time, method (*Time) MakeVDLTarget() vdl.Target
pkg time, method (*TimeTarget) FinishField(vdl.Target, vdl.Target) error
pkg time, method (*TimeTarget) FinishFields(vdl.FieldsTarget) error
+pkg time, method (*TimeTarget) FromZero(*vdl.Type) error
pkg time, method (*TimeTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg time, method (*TimeTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg time, method (*WireDeadline) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg time, method (*WireDeadline) MakeVDLTarget() vdl.Target
pkg time, method (*WireDeadlineTarget) FinishField(vdl.Target, vdl.Target) error
pkg time, method (*WireDeadlineTarget) FinishFields(vdl.FieldsTarget) error
+pkg time, method (*WireDeadlineTarget) FromZero(*vdl.Type) error
pkg time, method (*WireDeadlineTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg time, method (*WireDeadlineTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg time, method (Duration) Normalize() Duration
diff --git a/vdlroot/time/time.vdl.go b/vdlroot/time/time.vdl.go
index c2b310d..bb9083a 100644
--- a/vdlroot/time/time.vdl.go
+++ b/vdlroot/time/time.vdl.go
@@ -49,28 +49,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Seconds")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromInt(int64(m.Seconds), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Seconds == int64(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromInt(int64(m.Seconds), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Nanos")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Nanos")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromInt(int64(m.Nanos), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Nanos == int32(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromInt(int64(m.Nanos), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -124,6 +139,16 @@
}
return nil
}
+func (t *DurationTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = func() time.Duration {
+ var native time.Duration
+ if err := vdl.Convert(&native, Duration{}); err != nil {
+ panic(err)
+ }
+ return native
+ }()
+ return nil
+}
// Time represents an absolute point in time with up to nanosecond precision.
//
@@ -155,28 +180,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Seconds")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromInt(int64(m.Seconds), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Seconds == int64(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromInt(int64(m.Seconds), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Nanos")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Nanos")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromInt(int64(m.Nanos), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Nanos == int32(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromInt(int64(m.Nanos), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -230,6 +270,16 @@
}
return nil
}
+func (t *TimeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = func() time.Time {
+ var native time.Time
+ if err := vdl.Convert(&native, Time{}); err != nil {
+ panic(err)
+ }
+ return native
+ }()
+ return nil
+}
// WireDeadline represents the deadline for an operation, where the operation is
// expected to finish before the deadline. The intended usage is for a client
@@ -271,7 +321,6 @@
if err != nil {
return err
}
-
var wireValue2 Duration
if err := DurationFromNative(&wireValue2, m.FromNow); err != nil {
return err
@@ -283,22 +332,38 @@
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue2.FillVDLTarget(fieldTarget4, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var5 := (wireValue2 == Duration{})
+ if var5 {
+ if err := fieldTarget4.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue2.FillVDLTarget(fieldTarget4, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget3, fieldTarget4); err != nil {
return err
}
}
- keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("NoDeadline")
+ keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("NoDeadline")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget6.FromBool(bool(m.NoDeadline), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var8 := (m.NoDeadline == false)
+ if var8 {
+ if err := fieldTarget7.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget7.FromBool(bool(m.NoDeadline), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
return err
}
}
@@ -352,31 +417,16 @@
}
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroDuration = func() time.Duration {
- var native time.Duration
- if err := vdl.Convert(&native, Duration{}); err != nil {
- panic(err)
- }
- return native
- }()
- __VDLZeroTime = func() time.Time {
- var native time.Time
- if err := vdl.Convert(&native, Time{}); err != nil {
- panic(err)
- }
- return native
- }()
- __VDLZeroWireDeadline = func() Deadline {
+func (t *WireDeadlineTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = func() Deadline {
var native Deadline
if err := vdl.Convert(&native, WireDeadline{}); err != nil {
panic(err)
}
return native
}()
-)
+ return nil
+}
// Type-check native conversion functions.
var (
@@ -407,6 +457,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register native type conversions first, so that vdl.TypeOf works.
vdl.RegisterNative(DurationToNative, DurationFromNative)
diff --git a/vdlroot/vdltool/.api b/vdlroot/vdltool/.api
index 9464c07..6a7bb18 100644
--- a/vdlroot/vdltool/.api
+++ b/vdlroot/vdltool/.api
@@ -6,40 +6,47 @@
pkg vdltool, method (*Config) MakeVDLTarget() vdl.Target
pkg vdltool, method (*ConfigTarget) FinishField(vdl.Target, vdl.Target) error
pkg vdltool, method (*ConfigTarget) FinishFields(vdl.FieldsTarget) error
+pkg vdltool, method (*ConfigTarget) FromZero(*vdl.Type) error
pkg vdltool, method (*ConfigTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vdltool, method (*ConfigTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vdltool, method (*GenLanguage) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vdltool, method (*GenLanguage) MakeVDLTarget() vdl.Target
pkg vdltool, method (*GenLanguage) Set(string) error
pkg vdltool, method (*GenLanguageTarget) FromEnumLabel(string, *vdl.Type) error
+pkg vdltool, method (*GenLanguageTarget) FromZero(*vdl.Type) error
pkg vdltool, method (*GoConfig) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vdltool, method (*GoConfig) MakeVDLTarget() vdl.Target
pkg vdltool, method (*GoConfigTarget) FinishField(vdl.Target, vdl.Target) error
pkg vdltool, method (*GoConfigTarget) FinishFields(vdl.FieldsTarget) error
+pkg vdltool, method (*GoConfigTarget) FromZero(*vdl.Type) error
pkg vdltool, method (*GoConfigTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vdltool, method (*GoConfigTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vdltool, method (*GoImport) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vdltool, method (*GoImport) MakeVDLTarget() vdl.Target
pkg vdltool, method (*GoImportTarget) FinishField(vdl.Target, vdl.Target) error
pkg vdltool, method (*GoImportTarget) FinishFields(vdl.FieldsTarget) error
+pkg vdltool, method (*GoImportTarget) FromZero(*vdl.Type) error
pkg vdltool, method (*GoImportTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vdltool, method (*GoImportTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vdltool, method (*GoType) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vdltool, method (*GoType) MakeVDLTarget() vdl.Target
pkg vdltool, method (*GoTypeTarget) FinishField(vdl.Target, vdl.Target) error
pkg vdltool, method (*GoTypeTarget) FinishFields(vdl.FieldsTarget) error
+pkg vdltool, method (*GoTypeTarget) FromZero(*vdl.Type) error
pkg vdltool, method (*GoTypeTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vdltool, method (*GoTypeTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vdltool, method (*JavaConfig) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vdltool, method (*JavaConfig) MakeVDLTarget() vdl.Target
pkg vdltool, method (*JavaConfigTarget) FinishField(vdl.Target, vdl.Target) error
pkg vdltool, method (*JavaConfigTarget) FinishFields(vdl.FieldsTarget) error
+pkg vdltool, method (*JavaConfigTarget) FromZero(*vdl.Type) error
pkg vdltool, method (*JavaConfigTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vdltool, method (*JavaConfigTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vdltool, method (*JavascriptConfig) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vdltool, method (*JavascriptConfig) MakeVDLTarget() vdl.Target
pkg vdltool, method (*JavascriptConfigTarget) FinishField(vdl.Target, vdl.Target) error
pkg vdltool, method (*JavascriptConfigTarget) FinishFields(vdl.FieldsTarget) error
+pkg vdltool, method (*JavascriptConfigTarget) FromZero(*vdl.Type) error
pkg vdltool, method (*JavascriptConfigTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vdltool, method (*JavascriptConfigTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vdltool, method (GenLanguage) String() string
diff --git a/vdlroot/vdltool/config_test.go b/vdlroot/vdltool/config_test.go
index 303117a..91fba4f 100644
--- a/vdlroot/vdltool/config_test.go
+++ b/vdlroot/vdltool/config_test.go
@@ -11,10 +11,13 @@
"v.io/v23/vdl"
)
-// The Config's MakeVdlTarget is used to decode values in the vdl file.
-// Ensure that it decodes the values correctly. If this is not the case,
-// the vdl generator behaves incorrectly.
-func TestConfigMakeVdlTarget(t *testing.T) {
+// Ensure that a config can be loaded to a concrete value.
+// The reason this test is useful is to ensure that either the generated VdlConfig
+// target works correctly, or if it is not generated it is still possible to write
+// to the config using reflect.
+// If this is not the case (perhaps because of a broken vdltool.vdl.go),
+// unexpected behavior can result when generating files.
+func TestLoadingVdlConfig(t *testing.T) {
config := Config{
Go: GoConfig{
WireToNativeTypes: map[string]GoType{
@@ -56,7 +59,11 @@
configVdlValue := vdl.ValueOf(config)
var finalConfig Config
- if err := vdl.FromValue(finalConfig.MakeVDLTarget(), configVdlValue); err != nil {
+ target, err := vdl.ReflectTarget(reflect.ValueOf(&finalConfig))
+ if err != nil {
+ t.Fatalf("Error creating reflect target: %v", err)
+ }
+ if err := vdl.FromValue(target, configVdlValue); err != nil {
t.Fatalf("error while using ConfigTarget: %v", err)
}
diff --git a/vdlroot/vdltool/vdltool.vdl.go b/vdlroot/vdltool/vdltool.vdl.go
index 34f7bc1..238c115 100644
--- a/vdlroot/vdltool/vdltool.vdl.go
+++ b/vdlroot/vdltool/vdltool.vdl.go
@@ -11,6 +11,7 @@
import (
"fmt"
+ "reflect"
"v.io/v23/vdl"
)
@@ -81,7 +82,7 @@
}
func (m *GenLanguage) MakeVDLTarget() vdl.Target {
- return &GenLanguageTarget{Value: m}
+ return nil
}
type GenLanguageTarget struct {
@@ -102,11 +103,15 @@
case "Javascript":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum vdltool.GenLanguage", src)
+ return fmt.Errorf("label %s not in enum GenLanguage", src)
}
return nil
}
+func (t *GenLanguageTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = GenLanguageGo
+ return nil
+}
// GoImport describes Go import information.
type GoImport struct {
@@ -128,28 +133,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Path")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Path), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Path == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Path), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Name")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.Name), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Name == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.Name), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -160,13 +180,12 @@
}
func (m *GoImport) MakeVDLTarget() vdl.Target {
- return &GoImportTarget{Value: m}
+ return nil
}
type GoImportTarget struct {
- Value *GoImport
- pathTarget vdl.StringTarget
- nameTarget vdl.StringTarget
+ Value *GoImport
+
vdl.TargetBase
vdl.FieldsTargetBase
}
@@ -181,12 +200,10 @@
func (t *GoImportTarget) StartField(name string) (key, field vdl.Target, _ error) {
switch name {
case "Path":
- t.pathTarget.Value = &t.Value.Path
- target, err := &t.pathTarget, error(nil)
+ target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Path))
return nil, target, err
case "Name":
- t.nameTarget.Value = &t.Value.Name
- target, err := &t.nameTarget, error(nil)
+ target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Name))
return nil, target, err
default:
return nil, nil, fmt.Errorf("field %s not in struct vdltool.GoImport", name)
@@ -199,6 +216,10 @@
return nil
}
+func (t *GoImportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = GoImport{}
+ return nil
+}
// GoType describes the Go type information associated with a VDL type.
// See v.io/x/ref/lib/vdl/testdata/native for examples.
@@ -222,46 +243,64 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Type")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Type), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Type == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Type), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Imports")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Imports")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget6, err := fieldTarget5.StartList(tt.NonOptional().Field(1).Type, len(m.Imports))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.Imports) == 0 {
+ var7 = true
}
- for i, elem8 := range m.Imports {
- elemTarget7, err := listTarget6.StartElem(i)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.Imports))
if err != nil {
return err
}
+ for i, elem10 := range m.Imports {
+ elemTarget9, err := listTarget8.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem8.FillVDLTarget(elemTarget7, tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ return err
+ }
}
- if err := listTarget6.FinishElem(elemTarget7); err != nil {
+ if err := fieldTarget6.FinishList(listTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishList(listTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -272,13 +311,12 @@
}
func (m *GoType) MakeVDLTarget() vdl.Target {
- return &GoTypeTarget{Value: m}
+ return nil
}
type GoTypeTarget struct {
- Value *GoType
- typeTarget vdl.StringTarget
- importsTarget __VDLTarget1_list
+ Value *GoType
+
vdl.TargetBase
vdl.FieldsTargetBase
}
@@ -293,12 +331,10 @@
func (t *GoTypeTarget) StartField(name string) (key, field vdl.Target, _ error) {
switch name {
case "Type":
- t.typeTarget.Value = &t.Value.Type
- target, err := &t.typeTarget, error(nil)
+ target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Type))
return nil, target, err
case "Imports":
- t.importsTarget.Value = &t.Value.Imports
- target, err := &t.importsTarget, error(nil)
+ target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Imports))
return nil, target, err
default:
return nil, nil, fmt.Errorf("field %s not in struct vdltool.GoType", name)
@@ -311,37 +347,8 @@
return nil
}
-
-// []GoImport
-type __VDLTarget1_list struct {
- Value *[]GoImport
- elemTarget GoImportTarget
- vdl.TargetBase
- vdl.ListTargetBase
-}
-
-func (t *__VDLTarget1_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {
-
- if ttWant := vdl.TypeOf((*[]GoImport)(nil)); !vdl.Compatible(tt, ttWant) {
- return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
- }
- if cap(*t.Value) < len {
- *t.Value = make([]GoImport, len)
- } else {
- *t.Value = (*t.Value)[:len]
- }
- return t, nil
-}
-func (t *__VDLTarget1_list) StartElem(index int) (elem vdl.Target, _ error) {
- t.elemTarget.Value = &(*t.Value)[index]
- target, err := &t.elemTarget, error(nil)
- return target, err
-}
-func (t *__VDLTarget1_list) FinishElem(elem vdl.Target) error {
- return nil
-}
-func (t *__VDLTarget1_list) FinishList(elem vdl.ListTarget) error {
-
+func (t *GoTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = GoType{}
return nil
}
@@ -381,40 +388,50 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("WireToNativeTypes")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget4, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.WireToNativeTypes))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.WireToNativeTypes) == 0 {
+ var4 = true
}
- for key6, value8 := range m.WireToNativeTypes {
- keyTarget5, err := mapTarget4.StartKey()
- if err != nil {
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
return err
}
- if err := keyTarget5.FromString(string(key6), tt.NonOptional().Field(0).Type.Key()); err != nil {
- return err
- }
- valueTarget7, err := mapTarget4.FinishKeyStartField(keyTarget5)
- if err != nil {
- return err
- }
+ } else {
- if err := value8.FillVDLTarget(valueTarget7, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ mapTarget5, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.WireToNativeTypes))
+ if err != nil {
return err
}
- if err := mapTarget4.FinishField(keyTarget5, valueTarget7); err != nil {
+ for key7, value9 := range m.WireToNativeTypes {
+ keyTarget6, err := mapTarget5.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget6.FromString(string(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget8, err := mapTarget5.FinishKeyStartField(keyTarget6)
+ if err != nil {
+ return err
+ }
+
+ if err := value9.FillVDLTarget(valueTarget8, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget5.FinishField(keyTarget6, valueTarget8); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishMap(mapTarget5); err != nil {
return err
}
}
- if err := fieldTarget3.FinishMap(mapTarget4); err != nil {
- return err
- }
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
@@ -426,12 +443,12 @@
}
func (m *GoConfig) MakeVDLTarget() vdl.Target {
- return &GoConfigTarget{Value: m}
+ return nil
}
type GoConfigTarget struct {
- Value *GoConfig
- wireToNativeTypesTarget __VDLTarget2_map
+ Value *GoConfig
+
vdl.TargetBase
vdl.FieldsTargetBase
}
@@ -446,8 +463,7 @@
func (t *GoConfigTarget) StartField(name string) (key, field vdl.Target, _ error) {
switch name {
case "WireToNativeTypes":
- t.wireToNativeTypesTarget.Value = &t.Value.WireToNativeTypes
- target, err := &t.wireToNativeTypesTarget, error(nil)
+ target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.WireToNativeTypes))
return nil, target, err
default:
return nil, nil, fmt.Errorf("field %s not in struct vdltool.GoConfig", name)
@@ -460,47 +476,8 @@
return nil
}
-
-// map[string]GoType
-type __VDLTarget2_map struct {
- Value *map[string]GoType
- currKey string
- currElem GoType
- keyTarget vdl.StringTarget
- elemTarget GoTypeTarget
- vdl.TargetBase
- vdl.MapTargetBase
-}
-
-func (t *__VDLTarget2_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {
-
- if ttWant := vdl.TypeOf((*map[string]GoType)(nil)); !vdl.Compatible(tt, ttWant) {
- return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
- }
- *t.Value = make(map[string]GoType)
- return t, nil
-}
-func (t *__VDLTarget2_map) StartKey() (key vdl.Target, _ error) {
- t.currKey = ""
- t.keyTarget.Value = &t.currKey
- target, err := &t.keyTarget, error(nil)
- return target, err
-}
-func (t *__VDLTarget2_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
- t.currElem = GoType{}
- t.elemTarget.Value = &t.currElem
- target, err := &t.elemTarget, error(nil)
- return target, err
-}
-func (t *__VDLTarget2_map) FinishField(key, field vdl.Target) error {
- (*t.Value)[t.currKey] = t.currElem
- return nil
-}
-func (t *__VDLTarget2_map) FinishMap(elem vdl.MapTarget) error {
- if len(*t.Value) == 0 {
- *t.Value = nil
- }
-
+func (t *GoConfigTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = GoConfig{}
return nil
}
@@ -550,76 +527,97 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("WireToNativeTypes")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget4, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.WireToNativeTypes))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.WireToNativeTypes) == 0 {
+ var4 = true
}
- for key6, value8 := range m.WireToNativeTypes {
- keyTarget5, err := mapTarget4.StartKey()
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget5, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.WireToNativeTypes))
if err != nil {
return err
}
- if err := keyTarget5.FromString(string(key6), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ for key7, value9 := range m.WireToNativeTypes {
+ keyTarget6, err := mapTarget5.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget6.FromString(string(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget8, err := mapTarget5.FinishKeyStartField(keyTarget6)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget8.FromString(string(value9), tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget5.FinishField(keyTarget6, valueTarget8); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishMap(mapTarget5); err != nil {
return err
}
- valueTarget7, err := mapTarget4.FinishKeyStartField(keyTarget5)
- if err != nil {
- return err
- }
- if err := valueTarget7.FromString(string(value8), tt.NonOptional().Field(0).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget4.FinishField(keyTarget5, valueTarget7); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishMap(mapTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("WireTypeRenames")
+ keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("WireTypeRenames")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget11, err := fieldTarget10.StartMap(tt.NonOptional().Field(1).Type, len(m.WireTypeRenames))
- if err != nil {
- return err
+ var var12 bool
+ if len(m.WireTypeRenames) == 0 {
+ var12 = true
}
- for key13, value15 := range m.WireTypeRenames {
- keyTarget12, err := mapTarget11.StartKey()
+ if var12 {
+ if err := fieldTarget11.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget13, err := fieldTarget11.StartMap(tt.NonOptional().Field(1).Type, len(m.WireTypeRenames))
if err != nil {
return err
}
- if err := keyTarget12.FromString(string(key13), tt.NonOptional().Field(1).Type.Key()); err != nil {
- return err
+ for key15, value17 := range m.WireTypeRenames {
+ keyTarget14, err := mapTarget13.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget14.FromString(string(key15), tt.NonOptional().Field(1).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget16, err := mapTarget13.FinishKeyStartField(keyTarget14)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget16.FromString(string(value17), tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget13.FinishField(keyTarget14, valueTarget16); err != nil {
+ return err
+ }
}
- valueTarget14, err := mapTarget11.FinishKeyStartField(keyTarget12)
- if err != nil {
- return err
- }
- if err := valueTarget14.FromString(string(value15), tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget11.FinishField(keyTarget12, valueTarget14); err != nil {
+ if err := fieldTarget11.FinishMap(mapTarget13); err != nil {
return err
}
}
- if err := fieldTarget10.FinishMap(mapTarget11); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
return err
}
}
@@ -630,13 +628,12 @@
}
func (m *JavaConfig) MakeVDLTarget() vdl.Target {
- return &JavaConfigTarget{Value: m}
+ return nil
}
type JavaConfigTarget struct {
- Value *JavaConfig
- wireToNativeTypesTarget __VDLTarget3_map
- wireTypeRenamesTarget __VDLTarget3_map
+ Value *JavaConfig
+
vdl.TargetBase
vdl.FieldsTargetBase
}
@@ -651,12 +648,10 @@
func (t *JavaConfigTarget) StartField(name string) (key, field vdl.Target, _ error) {
switch name {
case "WireToNativeTypes":
- t.wireToNativeTypesTarget.Value = &t.Value.WireToNativeTypes
- target, err := &t.wireToNativeTypesTarget, error(nil)
+ target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.WireToNativeTypes))
return nil, target, err
case "WireTypeRenames":
- t.wireTypeRenamesTarget.Value = &t.Value.WireTypeRenames
- target, err := &t.wireTypeRenamesTarget, error(nil)
+ target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.WireTypeRenames))
return nil, target, err
default:
return nil, nil, fmt.Errorf("field %s not in struct vdltool.JavaConfig", name)
@@ -669,47 +664,8 @@
return nil
}
-
-// map[string]string
-type __VDLTarget3_map struct {
- Value *map[string]string
- currKey string
- currElem string
- keyTarget vdl.StringTarget
- elemTarget vdl.StringTarget
- vdl.TargetBase
- vdl.MapTargetBase
-}
-
-func (t *__VDLTarget3_map) StartMap(tt *vdl.Type, len int) (vdl.MapTarget, error) {
-
- if ttWant := vdl.TypeOf((*map[string]string)(nil)); !vdl.Compatible(tt, ttWant) {
- return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
- }
- *t.Value = make(map[string]string)
- return t, nil
-}
-func (t *__VDLTarget3_map) StartKey() (key vdl.Target, _ error) {
- t.currKey = ""
- t.keyTarget.Value = &t.currKey
- target, err := &t.keyTarget, error(nil)
- return target, err
-}
-func (t *__VDLTarget3_map) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
- t.currElem = ""
- t.elemTarget.Value = &t.currElem
- target, err := &t.elemTarget, error(nil)
- return target, err
-}
-func (t *__VDLTarget3_map) FinishField(key, field vdl.Target) error {
- (*t.Value)[t.currKey] = t.currElem
- return nil
-}
-func (t *__VDLTarget3_map) FinishMap(elem vdl.MapTarget) error {
- if len(*t.Value) == 0 {
- *t.Value = nil
- }
-
+func (t *JavaConfigTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = JavaConfig{}
return nil
}
@@ -727,7 +683,6 @@
if err != nil {
return err
}
-
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -735,7 +690,7 @@
}
func (m *JavascriptConfig) MakeVDLTarget() vdl.Target {
- return &JavascriptConfigTarget{Value: m}
+ return nil
}
type JavascriptConfigTarget struct {
@@ -764,6 +719,10 @@
return nil
}
+func (t *JavascriptConfigTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = JavascriptConfig{}
+ return nil
+}
// Config specifies the configuration for the vdl tool. This is typically
// represented in optional "vdl.config" files in each vdl source package. Each
@@ -789,73 +748,122 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("GenLanguages")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- setTarget4, err := fieldTarget3.StartSet(tt.NonOptional().Field(0).Type, len(m.GenLanguages))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.GenLanguages) == 0 {
+ var4 = true
}
- for key6 := range m.GenLanguages {
- keyTarget5, err := setTarget4.StartKey()
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ setTarget5, err := fieldTarget3.StartSet(tt.NonOptional().Field(0).Type, len(m.GenLanguages))
if err != nil {
return err
}
+ for key7 := range m.GenLanguages {
+ keyTarget6, err := setTarget5.StartKey()
+ if err != nil {
+ return err
+ }
- if err := key6.FillVDLTarget(keyTarget5, tt.NonOptional().Field(0).Type.Key()); err != nil {
+ if err := key7.FillVDLTarget(keyTarget6, tt.NonOptional().Field(0).Type.Key()); err != nil {
+ return err
+ }
+ if err := setTarget5.FinishKey(keyTarget6); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishSet(setTarget5); err != nil {
return err
}
- if err := setTarget4.FinishKey(keyTarget5); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishSet(setTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("Go")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Go")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Go.FillVDLTarget(fieldTarget8, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var10 := true
+ var var11 bool
+ if len(m.Go.WireToNativeTypes) == 0 {
+ var11 = true
}
- if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
+ var10 = var10 && var11
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Go.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Java")
+ keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("Java")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Java.FillVDLTarget(fieldTarget10, tt.NonOptional().Field(2).Type); err != nil {
- return err
+ var14 := true
+ var var15 bool
+ if len(m.Java.WireToNativeTypes) == 0 {
+ var15 = true
}
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
+ var14 = var14 && var15
+ var var16 bool
+ if len(m.Java.WireTypeRenames) == 0 {
+ var16 = true
+ }
+ var14 = var14 && var16
+ if var14 {
+ if err := fieldTarget13.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Java.FillVDLTarget(fieldTarget13, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
return err
}
}
- keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Javascript")
+ keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("Javascript")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Javascript.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
- return err
+ var19 := (m.Javascript == JavascriptConfig{})
+ if var19 {
+ if err := fieldTarget18.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Javascript.FillVDLTarget(fieldTarget18, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
return err
}
}
@@ -866,15 +874,12 @@
}
func (m *Config) MakeVDLTarget() vdl.Target {
- return &ConfigTarget{Value: m}
+ return nil
}
type ConfigTarget struct {
- Value *Config
- genLanguagesTarget __VDLTarget4_set
- goTarget GoConfigTarget
- javaTarget JavaConfigTarget
- javascriptTarget JavascriptConfigTarget
+ Value *Config
+
vdl.TargetBase
vdl.FieldsTargetBase
}
@@ -889,20 +894,16 @@
func (t *ConfigTarget) StartField(name string) (key, field vdl.Target, _ error) {
switch name {
case "GenLanguages":
- t.genLanguagesTarget.Value = &t.Value.GenLanguages
- target, err := &t.genLanguagesTarget, error(nil)
+ target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.GenLanguages))
return nil, target, err
case "Go":
- t.goTarget.Value = &t.Value.Go
- target, err := &t.goTarget, error(nil)
+ target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Go))
return nil, target, err
case "Java":
- t.javaTarget.Value = &t.Value.Java
- target, err := &t.javaTarget, error(nil)
+ target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Java))
return nil, target, err
case "Javascript":
- t.javascriptTarget.Value = &t.Value.Javascript
- target, err := &t.javascriptTarget, error(nil)
+ target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Javascript))
return nil, target, err
default:
return nil, nil, fmt.Errorf("field %s not in struct vdltool.Config", name)
@@ -915,52 +916,10 @@
return nil
}
-
-// map[GenLanguage]struct{}
-type __VDLTarget4_set struct {
- Value *map[GenLanguage]struct{}
- currKey GenLanguage
- keyTarget GenLanguageTarget
- vdl.TargetBase
- vdl.SetTargetBase
-}
-
-func (t *__VDLTarget4_set) StartSet(tt *vdl.Type, len int) (vdl.SetTarget, error) {
-
- if ttWant := vdl.TypeOf((*map[GenLanguage]struct{})(nil)); !vdl.Compatible(tt, ttWant) {
- return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
- }
- *t.Value = make(map[GenLanguage]struct{})
- return t, nil
-}
-func (t *__VDLTarget4_set) StartKey() (key vdl.Target, _ error) {
- t.currKey = GenLanguageGo
- t.keyTarget.Value = &t.currKey
- target, err := &t.keyTarget, error(nil)
- return target, err
-}
-func (t *__VDLTarget4_set) FinishKey(key vdl.Target) error {
- (*t.Value)[t.currKey] = struct{}{}
+func (t *ConfigTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Config{}
return nil
}
-func (t *__VDLTarget4_set) FinishSet(list vdl.SetTarget) error {
- if len(*t.Value) == 0 {
- *t.Value = nil
- }
-
- return nil
-}
-
-// Create zero values for each type.
-var (
- __VDLZeroGenLanguage = GenLanguageGo
- __VDLZeroGoImport = GoImport{}
- __VDLZeroGoType = GoType{}
- __VDLZeroGoConfig = GoConfig{}
- __VDLZeroJavaConfig = JavaConfig{}
- __VDLZeroJavascriptConfig = JavascriptConfig{}
- __VDLZeroConfig = Config{}
-)
var __VDLInitCalled bool
@@ -981,6 +940,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*GenLanguage)(nil))
diff --git a/verror/.api b/verror/.api
index a3255c0..1948860 100644
--- a/verror/.api
+++ b/verror/.api
@@ -40,7 +40,7 @@
pkg verror, func WireToNative(vdl.WireError, *E) error
pkg verror, func WithComponentName(*context.T, string) *context.T
pkg verror, method (*ErrorTarget) FinishFields(vdl.FieldsTarget) error
-pkg verror, method (*ErrorTarget) FromNil(*vdl.Type) error
+pkg verror, method (*ErrorTarget) FromZero(*vdl.Type) error
pkg verror, method (*ErrorTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg verror, method (ActionCode) RetryAction() ActionCode
pkg verror, method (E) Error() string
diff --git a/verror/verror.go b/verror/verror.go
index 2285c8f..b4d8873 100644
--- a/verror/verror.go
+++ b/verror/verror.go
@@ -653,7 +653,7 @@
vdl.FieldsTargetBase
}
-func (t *ErrorTarget) FromNil(tt *vdl.Type) error {
+func (t *ErrorTarget) FromZero(tt *vdl.Type) error {
if !vdl.Compatible(tt, vdl.ErrorType) {
return fmt.Errorf("Type %v incompatible with expected type %v", tt, vdl.ErrorType)
}
diff --git a/verror/verror.vdl.go b/verror/verror.vdl.go
index 28d8605..778b1f4 100644
--- a/verror/verror.vdl.go
+++ b/verror/verror.vdl.go
@@ -190,6 +190,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Set error format strings.
i18n.Cat().SetWithBase(i18n.LangID("en"), i18n.MsgID(ErrUnknown.ID), "{1:}{2:} Error{:_}")
diff --git a/vom/.api b/vom/.api
index dc12adf..d2134c9 100644
--- a/vom/.api
+++ b/vom/.api
@@ -62,18 +62,21 @@
pkg vom, method (*ControlKind) MakeVDLTarget() vdl.Target
pkg vom, method (*ControlKind) Set(string) error
pkg vom, method (*ControlKindTarget) FromEnumLabel(string, *vdl.Type) error
+pkg vom, method (*ControlKindTarget) FromZero(*vdl.Type) error
pkg vom, method (*Decoder) Decode(interface{}) error
pkg vom, method (*Decoder) Ignore() error
pkg vom, method (*DumpAtom) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vom, method (*DumpAtom) MakeVDLTarget() vdl.Target
pkg vom, method (*DumpAtomTarget) FinishField(vdl.Target, vdl.Target) error
pkg vom, method (*DumpAtomTarget) FinishFields(vdl.FieldsTarget) error
+pkg vom, method (*DumpAtomTarget) FromZero(*vdl.Type) error
pkg vom, method (*DumpAtomTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vom, method (*DumpAtomTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vom, method (*DumpKind) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vom, method (*DumpKind) MakeVDLTarget() vdl.Target
pkg vom, method (*DumpKind) Set(string) error
pkg vom, method (*DumpKindTarget) FromEnumLabel(string, *vdl.Type) error
+pkg vom, method (*DumpKindTarget) FromZero(*vdl.Type) error
pkg vom, method (*Dumper) Close() error
pkg vom, method (*Dumper) Flush() error
pkg vom, method (*Dumper) Status()
@@ -81,6 +84,7 @@
pkg vom, method (*Encoder) Encode(interface{}) error
pkg vom, method (*PrimitiveTarget) FinishField(vdl.Target, vdl.Target) error
pkg vom, method (*PrimitiveTarget) FinishFields(vdl.FieldsTarget) error
+pkg vom, method (*PrimitiveTarget) FromZero(*vdl.Type) error
pkg vom, method (*PrimitiveTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vom, method (*PrimitiveTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vom, method (*RawBytes) FillVDLTarget(vdl.Target, *vdl.Type) error
diff --git a/vom/decoder.go b/vom/decoder.go
index 44f9b03..6b229e0 100644
--- a/vom/decoder.go
+++ b/vom/decoder.go
@@ -284,7 +284,7 @@
return err
case ctrl == WireCtrlNil:
d.buf.Skip(1)
- return target.FromNil(ttFrom)
+ return target.FromZero(ttFrom)
}
tt = tt.Elem()
}
@@ -478,7 +478,7 @@
case err != nil:
return err
default:
- if err := vdl.FromValue(field, vdl.ZeroValue(ttfield.Type)); err != nil {
+ if err := field.FromZero(ttfield.Type); err != nil {
return err
}
if err := fieldsTarget.FinishField(key, field); err != nil {
@@ -540,7 +540,7 @@
return err
}
if elemType == nil {
- return target.FromNil(tt)
+ return target.FromZero(tt)
}
if hax, ok := target.(hasRvHack); ok {
rv := hax.HackGetRv()
diff --git a/vom/dump.go b/vom/dump.go
index 1386eec..c270329 100644
--- a/vom/dump.go
+++ b/vom/dump.go
@@ -554,7 +554,7 @@
case ctrl == WireCtrlNil:
d.buf.Skip(1)
d.writeAtom(DumpKindControl, PrimitivePControl{ControlKindNil}, "%v is nil", ttFrom)
- return target.FromNil(ttFrom)
+ return target.FromZero(ttFrom)
}
tt = tt.Elem()
}
@@ -835,7 +835,7 @@
return err
case ctrl == WireCtrlNil:
d.writeAtom(DumpKindControl, PrimitivePControl{ControlKindNil}, "any(nil)")
- return target.FromNil(vdl.AnyType)
+ return target.FromZero(vdl.AnyType)
case ctrl != 0:
return verror.New(errUnexpectedControlByte, nil, ctrl)
default:
diff --git a/vom/encoder.go b/vom/encoder.go
index 982d374..3004643 100644
--- a/vom/encoder.go
+++ b/vom/encoder.go
@@ -325,6 +325,7 @@
return err
}
}
+
// Handle the type id for Any values.
switch {
case len(e.typeStack) == 0:
@@ -332,7 +333,7 @@
// is called, to handle positive and negative ids, and the message length.
e.pushType(tt)
case !fromNil && e.topType().Kind() == vdl.Any:
- if e.isStructFieldValue() {
+ if e.isFieldValue() {
binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
}
if e.version == Version80 {
@@ -371,7 +372,7 @@
return e.typeStack[len(e.typeStack)-1].tt
}
-func (e *encoder) isStructFieldValue() bool {
+func (e *encoder) isFieldValue() bool {
return e.topTypeFieldIndex() >= 0
}
@@ -403,12 +404,11 @@
if err := e.prepareType(tt, boolAllowed...); err != nil {
return err
}
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- if src == true || !e.canIgnoreField(false) {
- binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
- } else {
+ if e.isFieldValue() && e.topType().Kind() != vdl.Any {
+ if src == false && e.canIgnoreField(false) {
return nil
}
+ binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
}
binaryEncodeBool(e.buf, src)
return nil
@@ -420,12 +420,11 @@
if err := e.prepareType(tt, uintAllowed...); err != nil {
return err
}
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- if src != 0 || !e.canIgnoreField(false) {
- binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
- } else {
+ if e.isFieldValue() && e.topType().Kind() != vdl.Any {
+ if src == 0 && e.canIgnoreField(false) {
return nil
}
+ binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
}
if e.version == Version80 && tt.Kind() == vdl.Byte {
e.buf.WriteOneByte(byte(src))
@@ -444,12 +443,11 @@
if e.version == Version80 && tt.Kind() == vdl.Int8 {
return verror.New(errUnsupportedInVOMVersion, nil, "int8", e.version)
}
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- if src != 0 || !e.canIgnoreField(false) {
- binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
- } else {
+ if e.isFieldValue() && e.topType().Kind() != vdl.Any {
+ if src == 0 && e.canIgnoreField(false) {
return nil
}
+ binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
}
binaryEncodeInt(e.buf, src)
return nil
@@ -461,12 +459,11 @@
if err := e.prepareType(tt, floatAllowed...); err != nil {
return err
}
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- if src != 0 || !e.canIgnoreField(false) {
- binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
- } else {
+ if e.isFieldValue() && e.topType().Kind() != vdl.Any {
+ if src == 0 && e.canIgnoreField(false) {
return nil
}
+ binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
}
binaryEncodeFloat(e.buf, src)
return nil
@@ -479,31 +476,25 @@
if err := e.prepareTypeHelper(tt, false); err != nil {
return err
}
- if tt.Kind() == vdl.List {
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- if len(src) != 0 || !e.canIgnoreField(false) {
- binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
- } else {
- return nil
- }
+ if e.isFieldValue() && e.topType().Kind() != vdl.Any {
+ if len(src) == 0 && e.canIgnoreField(false) {
+ return nil
}
- binaryEncodeUint(e.buf, uint64(len(src)))
- } else {
- // We always encode array length to 0.
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- var orData byte
- for _, b := range src {
- orData |= b
- }
- if orData != 0 || !e.canIgnoreField(false) {
- binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
- } else {
- return nil
- }
- }
- binaryEncodeUint(e.buf, uint64(0))
+ binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
}
-
+ switch tt.Kind() {
+ case vdl.List:
+ binaryEncodeUint(e.buf, uint64(len(src)))
+ case vdl.Array:
+ // Special-case the array length to always encode 0. We
+ // already have the length in the type, so technically
+ // we don't need to send any length for arrays. But if we
+ // don't encode a length, we'll be encoding the first array
+ // elem directly, so we won't be able to encode any flags.
+ // E.g. we won't be able to encode ?[3]byte. So we encode
+ // a dummy 0 length.
+ binaryEncodeUint(e.buf, 0)
+ }
e.buf.Write(src)
return nil
}
@@ -514,12 +505,11 @@
if err := e.prepareType(tt, stringAllowed...); err != nil {
return err
}
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- if len(src) != 0 || !e.canIgnoreField(false) {
- binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
- } else {
+ if e.isFieldValue() && e.topType().Kind() != vdl.Any {
+ if src == "" && e.canIgnoreField(false) {
return nil
}
+ binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
}
binaryEncodeString(e.buf, src)
return nil
@@ -535,12 +525,11 @@
if index < 0 {
return verror.New(errLabelNotInType, nil, src, tt)
}
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- if index != 0 || !e.canIgnoreField(false) {
- binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
- } else {
+ if e.isFieldValue() && e.topType().Kind() != vdl.Any {
+ if index == 0 && e.canIgnoreField(false) {
return nil
}
+ binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
}
binaryEncodeUint(e.buf, uint64(index))
return nil
@@ -557,8 +546,8 @@
if err != nil {
return err
}
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- if src.Kind() == vdl.Any && e.canIgnoreField(true) {
+ if e.isFieldValue() && e.topType().Kind() != vdl.Any {
+ if src == vdl.AnyType && e.canIgnoreField(false) {
return nil
}
binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
@@ -572,9 +561,92 @@
return nil
}
+func (e *encoder) FromZero(tt *vdl.Type) error {
+ // TODO(bprosnitz) Some cases such as unions, struct-valued struct fields and arrays aren't encoded as
+ // 0 and the full object is outputted. Fix this.
+ switch tt.Kind() {
+ case vdl.Bool:
+ return e.FromBool(false, tt)
+ case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64:
+ return e.FromUint(0, tt)
+ case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
+ return e.FromInt(0, tt)
+ case vdl.Float32, vdl.Float64:
+ return e.FromFloat(0, tt)
+ case vdl.String:
+ return e.FromString("", tt)
+ case vdl.Enum:
+ return e.FromEnumLabel(tt.EnumLabel(0), tt)
+ case vdl.TypeObject:
+ return e.FromTypeObject(vdl.AnyType)
+ case vdl.Any, vdl.Optional:
+ return e.fromNil(tt)
+ case vdl.List:
+ lt, err := e.StartList(tt, 0)
+ if err != nil {
+ return nil
+ }
+ return e.FinishList(lt)
+ case vdl.Array:
+ lt, err := e.StartList(tt, tt.Len())
+ if err != nil {
+ return nil
+ }
+ for i := 0; i < tt.Len(); i++ {
+ t, err := lt.StartElem(i)
+ if err != nil {
+ return err
+ }
+ if err := t.FromZero(tt.Elem()); err != nil {
+ return err
+ }
+ if err := lt.FinishElem(t); err != nil {
+ return err
+ }
+ }
+ return e.FinishList(lt)
+ case vdl.Map:
+ mt, err := e.StartMap(tt, 0)
+ if err != nil {
+ return nil
+ }
+ return e.FinishMap(mt)
+ case vdl.Set:
+ st, err := e.StartSet(tt, 0)
+ if err != nil {
+ return nil
+ }
+ return e.FinishSet(st)
+ case vdl.Struct:
+ ft, err := e.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ return e.FinishFields(ft)
+ case vdl.Union:
+ ft, err := e.StartFields(tt)
+ if err != nil {
+ return err
+ }
+ key, field, err := ft.StartField(tt.Field(0).Name)
+ if err != nil {
+ return err
+ }
+ if err := field.FromZero(tt.Field(0).Type); err != nil {
+ return err
+ }
+ if err := ft.FinishField(key, field); err != nil {
+ return err
+ }
+ return e.FinishFields(ft)
+ default:
+ return fmt.Errorf("unknown kind: %v", tt.Kind())
+ }
+}
+
var nilAllowed = []vdl.Kind{vdl.Any, vdl.Optional}
-func (e *encoder) FromNil(tt *vdl.Type) error {
+func (e *encoder) fromNil(tt *vdl.Type) error {
if !tt.CanBeNil() {
return errTypeMismatch(tt, nilAllowed...)
}
@@ -583,7 +655,7 @@
}
switch tt.Kind() {
case vdl.Optional:
- if e.isStructFieldValue() {
+ if e.isFieldValue() {
if !e.canIgnoreField(true) && e.topType().Kind() != vdl.Any {
binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
e.buf.WriteOneByte(WireCtrlNil)
@@ -592,7 +664,7 @@
e.buf.WriteOneByte(WireCtrlNil)
}
case vdl.Any:
- if e.isStructFieldValue() {
+ if e.isFieldValue() {
if !e.canIgnoreField(true) && e.topType().Kind() != vdl.Any {
e.buf.WriteOneByte(WireCtrlNil)
}
@@ -609,25 +681,18 @@
if err := e.prepareType(tt, listAllowed...); err != nil {
return nil, err
}
- if tt.Kind() == vdl.List {
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- if len != 0 || !e.canIgnoreField(false) {
- binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
- binaryEncodeUint(e.buf, uint64(len))
- }
- } else {
- binaryEncodeUint(e.buf, uint64(len))
+ if e.isFieldValue() && e.topType().Kind() != vdl.Any {
+ if len == 0 && e.canIgnoreField(false) {
+ e.pushType(tt)
+ return e, nil
}
- } else {
- // We always encode array length to 0.
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- if len != 0 || !e.canIgnoreField(false) {
- binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
- binaryEncodeUint(e.buf, uint64(0))
- }
- } else {
- binaryEncodeUint(e.buf, uint64(0))
- }
+ binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
+ }
+ switch tt.Kind() {
+ case vdl.List:
+ binaryEncodeUint(e.buf, uint64(len))
+ case vdl.Array:
+ binaryEncodeUint(e.buf, uint64(0))
}
e.pushType(tt)
return e, nil
@@ -639,14 +704,14 @@
if err := e.prepareType(tt, setAllowed...); err != nil {
return nil, err
}
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- if len != 0 || !e.canIgnoreField(false) {
- binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
- binaryEncodeUint(e.buf, uint64(len))
+ if e.isFieldValue() && e.topType().Kind() != vdl.Any {
+ if len == 0 && e.canIgnoreField(false) {
+ e.pushType(tt)
+ return e, nil
}
- } else {
- binaryEncodeUint(e.buf, uint64(len))
+ binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
}
+ binaryEncodeUint(e.buf, uint64(len))
e.pushType(tt)
return e, nil
}
@@ -657,14 +722,14 @@
if err := e.prepareType(tt, mapAllowed...); err != nil {
return nil, err
}
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
- if len != 0 || !e.canIgnoreField(false) {
- binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
- binaryEncodeUint(e.buf, uint64(len))
+ if e.isFieldValue() && e.topType().Kind() != vdl.Any {
+ if len == 0 && e.canIgnoreField(false) {
+ e.pushType(tt)
+ return e, nil
}
- } else {
- binaryEncodeUint(e.buf, uint64(len))
+ binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
}
+ binaryEncodeUint(e.buf, uint64(len))
e.pushType(tt)
return e, nil
}
@@ -672,7 +737,7 @@
var fieldsAllowed = []vdl.Kind{vdl.Struct, vdl.Union}
func (e *encoder) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
- if e.isStructFieldValue() && e.topType().Kind() != vdl.Any {
+ if e.isFieldValue() && e.topType().Kind() != vdl.Any {
// TODO(bprosnitz) We shouldn't need to write the struct field index for fields that are empty structs/unions
binaryEncodeUint(e.buf, uint64(e.topTypeFieldIndex()))
}
diff --git a/vom/internal/internal.vdl.go b/vom/internal/internal.vdl.go
index 14959c3..39b0d1e 100644
--- a/vom/internal/internal.vdl.go
+++ b/vom/internal/internal.vdl.go
@@ -34,55 +34,86 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Street")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Street), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Street == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Street), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("City")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("City")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.City), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.City == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.City), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("State")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("State")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromString(string(m.State), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Zip")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget9.FromString(string(m.Zip), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var10 := (m.State == "")
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromString(string(m.State), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Zip")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var13 := (m.Zip == "")
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget12.FromString(string(m.Zip), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -139,6 +170,10 @@
return nil
}
+func (t *AddressInfoTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = AddressInfo{}
+ return nil
+}
type CreditAgency int
@@ -222,11 +257,15 @@
case "TransUnion":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum v.io/v23/vom/internal.CreditAgency", src)
+ return fmt.Errorf("label %s not in enum CreditAgency", src)
}
return nil
}
+func (t *CreditAgencyTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = CreditAgencyEquifax
+ return nil
+}
type ExperianRating int
@@ -302,11 +341,15 @@
case "Bad":
*t.Value = 1
default:
- return fmt.Errorf("label %s not in enum v.io/v23/vom/internal.ExperianRating", src)
+ return fmt.Errorf("label %s not in enum ExperianRating", src)
}
return nil
}
+func (t *ExperianRatingTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ExperianRatingGood
+ return nil
+}
type EquifaxCreditReport struct {
Rating byte
@@ -322,14 +365,21 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromUint(uint64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Rating == byte(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromUint(uint64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -376,6 +426,10 @@
return nil
}
+func (t *EquifaxCreditReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = EquifaxCreditReport{}
+ return nil
+}
type ExperianCreditReport struct {
Rating ExperianRating
@@ -391,15 +445,22 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Rating.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Rating == ExperianRatingGood)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Rating.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -446,6 +507,10 @@
return nil
}
+func (t *ExperianCreditReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ExperianCreditReport{}
+ return nil
+}
type TransUnionCreditReport struct {
Rating int16
@@ -461,14 +526,21 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Rating")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromInt(int64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Rating == int16(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromInt(int64(m.Rating), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -515,6 +587,10 @@
return nil
}
+func (t *TransUnionCreditReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = TransUnionCreditReport{}
+ return nil
+}
type (
// AgencyReport represents any single field of the AgencyReport union type.
@@ -690,6 +766,10 @@
return nil
}
+func (t *AgencyReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = AgencyReport(AgencyReportEquifaxReport{})
+ return nil
+}
type agencyReportTargetFactory struct{}
@@ -715,34 +795,54 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Agency")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Agency.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Agency == CreditAgencyEquifax)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Agency.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Report")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Report")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- unionValue6 := m.Report
- if unionValue6 == nil {
- unionValue6 = AgencyReportEquifaxReport{}
+ var var7 bool
+ if field, ok := m.Report.(AgencyReportEquifaxReport); ok {
+
+ var8 := (field.Value == EquifaxCreditReport{})
+ var7 = var8
}
- if err := unionValue6.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ unionValue9 := m.Report
+ if unionValue9 == nil {
+ unionValue9 = AgencyReportEquifaxReport{}
+ }
+ if err := unionValue9.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -792,6 +892,12 @@
return nil
}
+func (t *CreditReportTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = CreditReport{
+ Report: AgencyReportEquifaxReport{},
+ }
+ return nil
+}
type Customer struct {
Name string
@@ -811,66 +917,107 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Id")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromInt(int64(m.Id), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Active")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromBool(bool(m.Active), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Address")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Id")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Address.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
+ var7 := (m.Id == int64(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromInt(int64(m.Id), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Active")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var10 := (m.Active == false)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromBool(bool(m.Active), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ }
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("Credit")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Address")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Credit.FillVDLTarget(fieldTarget11, tt.NonOptional().Field(4).Type); err != nil {
+ var13 := (m.Address == AddressInfo{})
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Address.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
+ }
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Credit")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var16 := (m.Credit == CreditReport{
+ Report: AgencyReportEquifaxReport{},
+ })
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Credit.FillVDLTarget(fieldTarget15, tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
@@ -935,25 +1082,14 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroAddressInfo = AddressInfo{}
- __VDLZeroCreditAgency = CreditAgencyEquifax
- __VDLZeroExperianRating = ExperianRatingGood
- __VDLZeroEquifaxCreditReport = EquifaxCreditReport{}
- __VDLZeroExperianCreditReport = ExperianCreditReport{}
- __VDLZeroTransUnionCreditReport = TransUnionCreditReport{}
- __VDLZeroAgencyReport = AgencyReport(AgencyReportEquifaxReport{})
- __VDLZeroCreditReport = CreditReport{
- Report: AgencyReportEquifaxReport{},
- }
- __VDLZeroCustomer = Customer{
+func (t *CustomerTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Customer{
Credit: CreditReport{
Report: AgencyReportEquifaxReport{},
},
}
-)
+ return nil
+}
var __VDLInitCalled bool
@@ -974,6 +1110,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*AddressInfo)(nil))
diff --git a/vom/raw_bytes.go b/vom/raw_bytes.go
index 32fe6c3..f1c448a 100644
--- a/vom/raw_bytes.go
+++ b/vom/raw_bytes.go
@@ -225,11 +225,12 @@
return r.finish()
}
-func (r *rbTarget) FromNil(tt *vdl.Type) error {
+func (r *rbTarget) FromZero(tt *vdl.Type) error {
+ // TODO(bprosnitz) This is likely slow, look into optimizing it
if err := r.start(tt); err != nil {
return err
}
- if err := r.enc.FromNil(tt); err != nil {
+ if err := vdl.FromValue(r.enc, vdl.ZeroValue(tt)); err != nil {
return err
}
return r.finish()
diff --git a/vom/testdata/data80/data80.vdl.go b/vom/testdata/data80/data80.vdl.go
index 1ffc653..2d22a45 100644
--- a/vom/testdata/data80/data80.vdl.go
+++ b/vom/testdata/data80/data80.vdl.go
@@ -1550,6 +1550,7 @@
B: true,
C: true,
E: vdl.AnyType,
+ F: vdl.ZeroValue(vdl.AnyType),
}),
TypeString: "v.io/v23/vom/testdata/types.MStruct struct{A bool;B v.io/v23/vom/testdata/types.NBool bool;C v.io/v23/vom/testdata/types.MBool bool;D ?v.io/v23/vom/testdata/types.NStruct struct{A bool;B string;C int64};E typeobject;F any}",
Hex: "805327000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e426f6f6c0101e15527000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d426f6f6c0101e1593b060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e53747275637401030001410101e10001420103e10001430109e1e1570408012de1514d060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d53747275637401060001410101e1000142012ae1000143012be1000144012ce1000145010ee1000146010fe1e15207000101010201e1",
@@ -1561,6 +1562,7 @@
Name: "types.MStruct{}",
Value: vdl.ValueOf(types.MStruct{
E: vdl.AnyType,
+ F: vdl.ZeroValue(vdl.AnyType),
}),
TypeString: "v.io/v23/vom/testdata/types.MStruct struct{A bool;B v.io/v23/vom/testdata/types.NBool bool;C v.io/v23/vom/testdata/types.MBool bool;D ?v.io/v23/vom/testdata/types.NStruct struct{A bool;B string;C int64};E typeobject;F any}",
Hex: "805327000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e426f6f6c0101e15527000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d426f6f6c0101e1593b060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e53747275637401030001410101e10001420103e10001430109e1e1570408012de1514d060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d53747275637401060001410101e1000142012ae1000143012be1000144012ce1000145010ee1000146010fe1e15201e1",
@@ -1573,6 +1575,7 @@
Value: vdl.ValueOf(types.MStruct{
D: &types.NStruct{},
E: vdl.AnyType,
+ F: vdl.ZeroValue(vdl.AnyType),
}),
TypeString: "v.io/v23/vom/testdata/types.MStruct struct{A bool;B v.io/v23/vom/testdata/types.NBool bool;C v.io/v23/vom/testdata/types.MBool bool;D ?v.io/v23/vom/testdata/types.NStruct struct{A bool;B string;C int64};E typeobject;F any}",
Hex: "805327000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e426f6f6c0101e15527000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d426f6f6c0101e1593b060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e53747275637401030001410101e10001420103e10001430109e1e1570408012de1514d060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d53747275637401060001410101e1000142012ae1000143012be1000144012ce1000145010ee1000146010fe1e1520303e1e1",
@@ -1589,6 +1592,7 @@
C: 123,
},
E: vdl.AnyType,
+ F: vdl.ZeroValue(vdl.AnyType),
}),
TypeString: "v.io/v23/vom/testdata/types.MStruct struct{A bool;B v.io/v23/vom/testdata/types.NBool bool;C v.io/v23/vom/testdata/types.MBool bool;D ?v.io/v23/vom/testdata/types.NStruct struct{A bool;B string;C int64};E typeobject;F any}",
Hex: "805327000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e426f6f6c0101e15527000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d426f6f6c0101e1593b060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e53747275637401030001410101e10001420103e10001430109e1e1570408012de1514d060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d53747275637401060001410101e1000142012ae1000143012be1000144012ce1000145010ee1000146010fe1e1520d030001010361626302fff6e1e1",
@@ -2054,8 +2058,10 @@
HexValue: "5203020f01",
},
{
- Name: "types.StructAny{}",
- Value: vdl.ValueOf(types.StructAny{}),
+ Name: "types.StructAny{}",
+ Value: vdl.ValueOf(types.StructAny{
+ Any: vdl.ZeroValue(vdl.AnyType),
+ }),
TypeString: "v.io/v23/vom/testdata/types.StructAny struct{Any any}",
Hex: "805133060025762e696f2f7632332f766f6d2f74657374646174612f74797065732e537472756374416e7901010003416e79010fe1e15201e1",
HexVersion: "80",
@@ -2318,8 +2324,10 @@
HexValue: "5201e0",
},
{
- Name: "?types.StructAny{}",
- Value: vdl.ValueOf(&types.StructAny{}),
+ Name: "?types.StructAny{}",
+ Value: vdl.ValueOf(&types.StructAny{
+ Any: vdl.ZeroValue(vdl.AnyType),
+ }),
TypeString: "?v.io/v23/vom/testdata/types.StructAny struct{Any any}",
Hex: "805333060025762e696f2f7632332f766f6d2f74657374646174612f74797065732e537472756374416e7901010003416e79010fe1e1510408012ae15201e1",
HexVersion: "80",
@@ -2612,6 +2620,7 @@
},
{
Name: "any(nil)",
+ Value: vdl.ZeroValue(vdl.AnyType),
TypeString: "any",
Hex: "801e01e0",
HexVersion: "80",
@@ -3351,6 +3360,7 @@
}),
vdl.ValueOf(types.AdeStruct{
A: true,
+ D: vdl.ZeroValue(vdl.AnyType),
E: vdl.AnyType,
}),
vdl.ValueOf(types.NStruct{
@@ -3484,6 +3494,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
return struct{}{}
}
diff --git a/vom/testdata/data81/data81.vdl.go b/vom/testdata/data81/data81.vdl.go
index cdca683..c929ad4 100644
--- a/vom/testdata/data81/data81.vdl.go
+++ b/vom/testdata/data81/data81.vdl.go
@@ -1550,6 +1550,7 @@
B: true,
C: true,
E: vdl.AnyType,
+ F: vdl.ZeroValue(vdl.AnyType),
}),
TypeString: "v.io/v23/vom/testdata/types.MStruct struct{A bool;B v.io/v23/vom/testdata/types.NBool bool;C v.io/v23/vom/testdata/types.MBool bool;D ?v.io/v23/vom/testdata/types.NStruct struct{A bool;B string;C int64};E typeobject;F any}",
Hex: "815327000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e426f6f6c0101e15527000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d426f6f6c0101e1593b060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e53747275637401030001410101e10001420103e10001430109e1e1570408012de1514d060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d53747275637401060001410101e1000142012ae1000143012be1000144012ce1000145010ee1000146010fe1e152000007000101010201e1",
@@ -1561,6 +1562,7 @@
Name: "types.MStruct{}",
Value: vdl.ValueOf(types.MStruct{
E: vdl.AnyType,
+ F: vdl.ZeroValue(vdl.AnyType),
}),
TypeString: "v.io/v23/vom/testdata/types.MStruct struct{A bool;B v.io/v23/vom/testdata/types.NBool bool;C v.io/v23/vom/testdata/types.MBool bool;D ?v.io/v23/vom/testdata/types.NStruct struct{A bool;B string;C int64};E typeobject;F any}",
Hex: "815327000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e426f6f6c0101e15527000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d426f6f6c0101e1593b060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e53747275637401030001410101e10001420103e10001430109e1e1570408012de1514d060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d53747275637401060001410101e1000142012ae1000143012be1000144012ce1000145010ee1000146010fe1e152000001e1",
@@ -1573,6 +1575,7 @@
Value: vdl.ValueOf(types.MStruct{
D: &types.NStruct{},
E: vdl.AnyType,
+ F: vdl.ZeroValue(vdl.AnyType),
}),
TypeString: "v.io/v23/vom/testdata/types.MStruct struct{A bool;B v.io/v23/vom/testdata/types.NBool bool;C v.io/v23/vom/testdata/types.MBool bool;D ?v.io/v23/vom/testdata/types.NStruct struct{A bool;B string;C int64};E typeobject;F any}",
Hex: "815327000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e426f6f6c0101e15527000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d426f6f6c0101e1593b060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e53747275637401030001410101e10001420103e10001430109e1e1570408012de1514d060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d53747275637401060001410101e1000142012ae1000143012be1000144012ce1000145010ee1000146010fe1e15200000303e1e1",
@@ -1589,6 +1592,7 @@
C: 123,
},
E: vdl.AnyType,
+ F: vdl.ZeroValue(vdl.AnyType),
}),
TypeString: "v.io/v23/vom/testdata/types.MStruct struct{A bool;B v.io/v23/vom/testdata/types.NBool bool;C v.io/v23/vom/testdata/types.MBool bool;D ?v.io/v23/vom/testdata/types.NStruct struct{A bool;B string;C int64};E typeobject;F any}",
Hex: "815327000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e426f6f6c0101e15527000021762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d426f6f6c0101e1593b060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e53747275637401030001410101e10001420103e10001430109e1e1570408012de1514d060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4d53747275637401060001410101e1000142012ae1000143012be1000144012ce1000145010ee1000146010fe1e15200000d030001010361626302fff6e1e1",
@@ -2054,8 +2058,10 @@
HexValue: "52020f0103020001",
},
{
- Name: "types.StructAny{}",
- Value: vdl.ValueOf(types.StructAny{}),
+ Name: "types.StructAny{}",
+ Value: vdl.ValueOf(types.StructAny{
+ Any: vdl.ZeroValue(vdl.AnyType),
+ }),
TypeString: "v.io/v23/vom/testdata/types.StructAny struct{Any any}",
Hex: "815133060025762e696f2f7632332f766f6d2f74657374646174612f74797065732e537472756374416e7901010003416e79010fe1e152000001e1",
HexVersion: "81",
@@ -2318,8 +2324,10 @@
HexValue: "52000001e0",
},
{
- Name: "?types.StructAny{}",
- Value: vdl.ValueOf(&types.StructAny{}),
+ Name: "?types.StructAny{}",
+ Value: vdl.ValueOf(&types.StructAny{
+ Any: vdl.ZeroValue(vdl.AnyType),
+ }),
TypeString: "?v.io/v23/vom/testdata/types.StructAny struct{Any any}",
Hex: "815333060025762e696f2f7632332f766f6d2f74657374646174612f74797065732e537472756374416e7901010003416e79010fe1e1510408012ae152000001e1",
HexVersion: "81",
@@ -2612,6 +2620,7 @@
},
{
Name: "any(nil)",
+ Value: vdl.ZeroValue(vdl.AnyType),
TypeString: "any",
Hex: "811e000001e0",
HexVersion: "81",
@@ -3451,6 +3460,7 @@
}),
vdl.ValueOf(types.AdeStruct{
A: true,
+ D: vdl.ZeroValue(vdl.AnyType),
E: vdl.AnyType,
}),
vdl.ValueOf(types.NStruct{
@@ -3584,6 +3594,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
return struct{}{}
}
diff --git a/vom/testdata/types/types.vdl.go b/vom/testdata/types/types.vdl.go
index 04062e9..07dfe0c 100644
--- a/vom/testdata/types/types.vdl.go
+++ b/vom/testdata/types/types.vdl.go
@@ -40,98 +40,153 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Value")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Value")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.Value == nil {
- if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
+ var7 := (m.Value == vdl.ZeroValue(vdl.AnyType))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- if err := vdl.FromValue(fieldTarget5, m.Value); err != nil {
- return err
+
+ if m.Value == nil {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := vdl.FromValue(fieldTarget6, m.Value); err != nil {
+ return err
+ }
}
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("TypeString")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("TypeString")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromString(string(m.TypeString), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Hex")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget9.FromString(string(m.Hex), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var10 := (m.TypeString == "")
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromString(string(m.TypeString), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("HexVersion")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Hex")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget11.FromString(string(m.HexVersion), tt.NonOptional().Field(4).Type); err != nil {
- return err
+
+ var13 := (m.Hex == "")
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget12.FromString(string(m.Hex), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
- keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("HexType")
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("HexVersion")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget13.FromString(string(m.HexType), tt.NonOptional().Field(5).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
- return err
- }
- }
- keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("HexValue")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget15.FromString(string(m.HexValue), tt.NonOptional().Field(6).Type); err != nil {
- return err
+
+ var16 := (m.HexVersion == "")
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget15.FromString(string(m.HexVersion), tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
+ keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("HexType")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var19 := (m.HexType == "")
+ if var19 {
+ if err := fieldTarget18.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget18.FromString(string(m.HexType), tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
+ return err
+ }
+ }
+ keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("HexValue")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var22 := (m.HexValue == "")
+ if var22 {
+ if err := fieldTarget21.FromZero(tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget21.FromString(string(m.HexValue), tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -202,6 +257,12 @@
return nil
}
+func (t *TestCaseTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = TestCase{
+ Value: vdl.ZeroValue(vdl.AnyType),
+ }
+ return nil
+}
// vomdata config types
type ConvertGroup struct {
@@ -220,68 +281,94 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("PrimaryType")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- typeObjectVal6 := m.PrimaryType
- if typeObjectVal6 == nil {
- typeObjectVal6 = vdl.AnyType
- }
- if err := fieldTarget5.FromTypeObject(typeObjectVal6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("Values")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("PrimaryType")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget9, err := fieldTarget8.StartList(tt.NonOptional().Field(2).Type, len(m.Values))
- if err != nil {
+ var7 := (m.PrimaryType == vdl.AnyType)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ typeObjectVal8 := m.PrimaryType
+ if typeObjectVal8 == nil {
+ typeObjectVal8 = vdl.AnyType
+ }
+ if err := fieldTarget6.FromTypeObject(typeObjectVal8); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
- for i, elem11 := range m.Values {
- elemTarget10, err := listTarget9.StartElem(i)
+ }
+ keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Values")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var11 bool
+ if len(m.Values) == 0 {
+ var11 = true
+ }
+ if var11 {
+ if err := fieldTarget10.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget12, err := fieldTarget10.StartList(tt.NonOptional().Field(2).Type, len(m.Values))
if err != nil {
return err
}
-
- if elem11 == nil {
- if err := elemTarget10.FromNil(tt.NonOptional().Field(2).Type.Elem()); err != nil {
+ for i, elem14 := range m.Values {
+ elemTarget13, err := listTarget12.StartElem(i)
+ if err != nil {
return err
}
- } else {
- if err := vdl.FromValue(elemTarget10, elem11); err != nil {
+
+ if elem14 == nil {
+ if err := elemTarget13.FromZero(tt.NonOptional().Field(2).Type.Elem()); err != nil {
+ return err
+ }
+ } else {
+ if err := vdl.FromValue(elemTarget13, elem14); err != nil {
+ return err
+ }
+ }
+ if err := listTarget12.FinishElem(elemTarget13); err != nil {
return err
}
}
- if err := listTarget9.FinishElem(elemTarget10); err != nil {
+ if err := fieldTarget10.FinishList(listTarget12); err != nil {
return err
}
}
- if err := fieldTarget8.FinishList(listTarget9); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
return err
}
}
@@ -336,6 +423,12 @@
return nil
}
+func (t *ConvertGroupTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ConvertGroup{
+ PrimaryType: vdl.AnyType,
+ }
+ return nil
+}
// []*vdl.Value
type __VDLTarget1_list struct {
@@ -368,6 +461,10 @@
return nil
}
+func (t *__VDLTarget1_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []*vdl.Value(nil)
+ return nil
+}
type VomdataStruct struct {
EncodeDecodeData map[byte][]*vdl.Value // map from min required VOM version to test values
@@ -385,175 +482,207 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("EncodeDecodeData")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget4, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.EncodeDecodeData))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.EncodeDecodeData) == 0 {
+ var4 = true
}
- for key6, value8 := range m.EncodeDecodeData {
- keyTarget5, err := mapTarget4.StartKey()
- if err != nil {
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
return err
}
- if err := keyTarget5.FromUint(uint64(key6), tt.NonOptional().Field(0).Type.Key()); err != nil {
- return err
- }
- valueTarget7, err := mapTarget4.FinishKeyStartField(keyTarget5)
- if err != nil {
- return err
- }
+ } else {
- listTarget9, err := valueTarget7.StartList(tt.NonOptional().Field(0).Type.Elem(), len(value8))
+ mapTarget5, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.EncodeDecodeData))
if err != nil {
return err
}
- for i, elem11 := range value8 {
- elemTarget10, err := listTarget9.StartElem(i)
+ for key7, value9 := range m.EncodeDecodeData {
+ keyTarget6, err := mapTarget5.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget6.FromUint(uint64(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget8, err := mapTarget5.FinishKeyStartField(keyTarget6)
if err != nil {
return err
}
- if elem11 == nil {
- if err := elemTarget10.FromNil(tt.NonOptional().Field(0).Type.Elem().Elem()); err != nil {
+ listTarget10, err := valueTarget8.StartList(tt.NonOptional().Field(0).Type.Elem(), len(value9))
+ if err != nil {
+ return err
+ }
+ for i, elem12 := range value9 {
+ elemTarget11, err := listTarget10.StartElem(i)
+ if err != nil {
return err
}
- } else {
- if err := vdl.FromValue(elemTarget10, elem11); err != nil {
+
+ if elem12 == nil {
+ if err := elemTarget11.FromZero(tt.NonOptional().Field(0).Type.Elem().Elem()); err != nil {
+ return err
+ }
+ } else {
+ if err := vdl.FromValue(elemTarget11, elem12); err != nil {
+ return err
+ }
+ }
+ if err := listTarget10.FinishElem(elemTarget11); err != nil {
return err
}
}
- if err := listTarget9.FinishElem(elemTarget10); err != nil {
+ if err := valueTarget8.FinishList(listTarget10); err != nil {
+ return err
+ }
+ if err := mapTarget5.FinishField(keyTarget6, valueTarget8); err != nil {
return err
}
}
- if err := valueTarget7.FinishList(listTarget9); err != nil {
+ if err := fieldTarget3.FinishMap(mapTarget5); err != nil {
return err
}
- if err := mapTarget4.FinishField(keyTarget5, valueTarget7); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishMap(mapTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("CompatData")
+ keyTarget13, fieldTarget14, err := fieldsTarget1.StartField("CompatData")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget14, err := fieldTarget13.StartMap(tt.NonOptional().Field(1).Type, len(m.CompatData))
- if err != nil {
- return err
+ var var15 bool
+ if len(m.CompatData) == 0 {
+ var15 = true
}
- for key16, value18 := range m.CompatData {
- keyTarget15, err := mapTarget14.StartKey()
- if err != nil {
+ if var15 {
+ if err := fieldTarget14.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
- if err := keyTarget15.FromString(string(key16), tt.NonOptional().Field(1).Type.Key()); err != nil {
- return err
- }
- valueTarget17, err := mapTarget14.FinishKeyStartField(keyTarget15)
- if err != nil {
- return err
- }
+ } else {
- listTarget19, err := valueTarget17.StartList(tt.NonOptional().Field(1).Type.Elem(), len(value18))
+ mapTarget16, err := fieldTarget14.StartMap(tt.NonOptional().Field(1).Type, len(m.CompatData))
if err != nil {
return err
}
- for i, elem21 := range value18 {
- elemTarget20, err := listTarget19.StartElem(i)
+ for key18, value20 := range m.CompatData {
+ keyTarget17, err := mapTarget16.StartKey()
if err != nil {
return err
}
- typeObjectVal22 := elem21
- if typeObjectVal22 == nil {
- typeObjectVal22 = vdl.AnyType
- }
- if err := elemTarget20.FromTypeObject(typeObjectVal22); err != nil {
+ if err := keyTarget17.FromString(string(key18), tt.NonOptional().Field(1).Type.Key()); err != nil {
return err
}
- if err := listTarget19.FinishElem(elemTarget20); err != nil {
+ valueTarget19, err := mapTarget16.FinishKeyStartField(keyTarget17)
+ if err != nil {
+ return err
+ }
+
+ listTarget21, err := valueTarget19.StartList(tt.NonOptional().Field(1).Type.Elem(), len(value20))
+ if err != nil {
+ return err
+ }
+ for i, elem23 := range value20 {
+ elemTarget22, err := listTarget21.StartElem(i)
+ if err != nil {
+ return err
+ }
+ typeObjectVal24 := elem23
+ if typeObjectVal24 == nil {
+ typeObjectVal24 = vdl.AnyType
+ }
+ if err := elemTarget22.FromTypeObject(typeObjectVal24); err != nil {
+ return err
+ }
+ if err := listTarget21.FinishElem(elemTarget22); err != nil {
+ return err
+ }
+ }
+ if err := valueTarget19.FinishList(listTarget21); err != nil {
+ return err
+ }
+ if err := mapTarget16.FinishField(keyTarget17, valueTarget19); err != nil {
return err
}
}
- if err := valueTarget17.FinishList(listTarget19); err != nil {
- return err
- }
- if err := mapTarget14.FinishField(keyTarget15, valueTarget17); err != nil {
+ if err := fieldTarget14.FinishMap(mapTarget16); err != nil {
return err
}
}
- if err := fieldTarget13.FinishMap(mapTarget14); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget13, fieldTarget14); err != nil {
return err
}
}
- keyTarget23, fieldTarget24, err := fieldsTarget1.StartField("ConvertData")
+ keyTarget25, fieldTarget26, err := fieldsTarget1.StartField("ConvertData")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget25, err := fieldTarget24.StartMap(tt.NonOptional().Field(2).Type, len(m.ConvertData))
- if err != nil {
- return err
+ var var27 bool
+ if len(m.ConvertData) == 0 {
+ var27 = true
}
- for key27, value29 := range m.ConvertData {
- keyTarget26, err := mapTarget25.StartKey()
- if err != nil {
+ if var27 {
+ if err := fieldTarget26.FromZero(tt.NonOptional().Field(2).Type); err != nil {
return err
}
- if err := keyTarget26.FromString(string(key27), tt.NonOptional().Field(2).Type.Key()); err != nil {
- return err
- }
- valueTarget28, err := mapTarget25.FinishKeyStartField(keyTarget26)
- if err != nil {
- return err
- }
+ } else {
- listTarget30, err := valueTarget28.StartList(tt.NonOptional().Field(2).Type.Elem(), len(value29))
+ mapTarget28, err := fieldTarget26.StartMap(tt.NonOptional().Field(2).Type, len(m.ConvertData))
if err != nil {
return err
}
- for i, elem32 := range value29 {
- elemTarget31, err := listTarget30.StartElem(i)
+ for key30, value32 := range m.ConvertData {
+ keyTarget29, err := mapTarget28.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget29.FromString(string(key30), tt.NonOptional().Field(2).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget31, err := mapTarget28.FinishKeyStartField(keyTarget29)
if err != nil {
return err
}
- if err := elem32.FillVDLTarget(elemTarget31, tt.NonOptional().Field(2).Type.Elem().Elem()); err != nil {
+ listTarget33, err := valueTarget31.StartList(tt.NonOptional().Field(2).Type.Elem(), len(value32))
+ if err != nil {
return err
}
- if err := listTarget30.FinishElem(elemTarget31); err != nil {
+ for i, elem35 := range value32 {
+ elemTarget34, err := listTarget33.StartElem(i)
+ if err != nil {
+ return err
+ }
+
+ if err := elem35.FillVDLTarget(elemTarget34, tt.NonOptional().Field(2).Type.Elem().Elem()); err != nil {
+ return err
+ }
+ if err := listTarget33.FinishElem(elemTarget34); err != nil {
+ return err
+ }
+ }
+ if err := valueTarget31.FinishList(listTarget33); err != nil {
+ return err
+ }
+ if err := mapTarget28.FinishField(keyTarget29, valueTarget31); err != nil {
return err
}
}
- if err := valueTarget28.FinishList(listTarget30); err != nil {
- return err
- }
- if err := mapTarget25.FinishField(keyTarget26, valueTarget28); err != nil {
+ if err := fieldTarget26.FinishMap(mapTarget28); err != nil {
return err
}
}
- if err := fieldTarget24.FinishMap(mapTarget25); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget23, fieldTarget24); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget25, fieldTarget26); err != nil {
return err
}
}
@@ -608,6 +737,10 @@
return nil
}
+func (t *VomdataStructTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = VomdataStruct{}
+ return nil
+}
// map[byte][]*vdl.Value
type __VDLTarget2_map struct {
@@ -651,6 +784,10 @@
return nil
}
+func (t *__VDLTarget2_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[byte][]*vdl.Value(nil)
+ return nil
+}
// map[string][]*vdl.Type
type __VDLTarget3_map struct {
@@ -694,6 +831,10 @@
return nil
}
+func (t *__VDLTarget3_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[string][]*vdl.Type(nil)
+ return nil
+}
// []*vdl.Type
type __VDLTarget5_list struct {
@@ -727,6 +868,10 @@
return nil
}
+func (t *__VDLTarget5_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []*vdl.Type(nil)
+ return nil
+}
// map[string][]ConvertGroup
type __VDLTarget4_map struct {
@@ -770,6 +915,10 @@
return nil
}
+func (t *__VDLTarget4_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[string][]ConvertGroup(nil)
+ return nil
+}
// []ConvertGroup
type __VDLTarget6_list struct {
@@ -803,6 +952,10 @@
return nil
}
+func (t *__VDLTarget6_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []ConvertGroup(nil)
+ return nil
+}
// Named Types
type NBool bool
@@ -837,6 +990,10 @@
return nil
}
+func (t *NBoolTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = NBool(false)
+ return nil
+}
type NString string
@@ -870,6 +1027,10 @@
return nil
}
+func (t *NStringTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = NString("")
+ return nil
+}
type NByteSlice []byte
@@ -908,6 +1069,10 @@
return nil
}
+func (t *NByteSliceTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = NByteSlice(nil)
+ return nil
+}
type NByteArray [4]byte
@@ -941,6 +1106,10 @@
return nil
}
+func (t *NByteArrayTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = NByteArray{}
+ return nil
+}
type NByte byte
@@ -995,6 +1164,10 @@
return nil
}
+func (t *NByteTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = NByte(0)
+ return nil
+}
type NUint16 uint16
@@ -1049,6 +1222,10 @@
return nil
}
+func (t *NUint16Target) FromZero(tt *vdl.Type) error {
+ *t.Value = NUint16(0)
+ return nil
+}
type NUint32 uint32
@@ -1103,6 +1280,10 @@
return nil
}
+func (t *NUint32Target) FromZero(tt *vdl.Type) error {
+ *t.Value = NUint32(0)
+ return nil
+}
type NUint64 uint64
@@ -1153,6 +1334,10 @@
return nil
}
+func (t *NUint64Target) FromZero(tt *vdl.Type) error {
+ *t.Value = NUint64(0)
+ return nil
+}
type NInt8 int8
@@ -1207,6 +1392,10 @@
return nil
}
+func (t *NInt8Target) FromZero(tt *vdl.Type) error {
+ *t.Value = NInt8(0)
+ return nil
+}
type NInt16 int16
@@ -1261,6 +1450,10 @@
return nil
}
+func (t *NInt16Target) FromZero(tt *vdl.Type) error {
+ *t.Value = NInt16(0)
+ return nil
+}
type NInt32 int32
@@ -1315,6 +1508,10 @@
return nil
}
+func (t *NInt32Target) FromZero(tt *vdl.Type) error {
+ *t.Value = NInt32(0)
+ return nil
+}
type NInt64 int64
@@ -1365,6 +1562,10 @@
return nil
}
+func (t *NInt64Target) FromZero(tt *vdl.Type) error {
+ *t.Value = NInt64(0)
+ return nil
+}
type NFloat32 float32
@@ -1419,6 +1620,10 @@
return nil
}
+func (t *NFloat32Target) FromZero(tt *vdl.Type) error {
+ *t.Value = NFloat32(0)
+ return nil
+}
type NFloat64 float64
@@ -1469,6 +1674,10 @@
return nil
}
+func (t *NFloat64Target) FromZero(tt *vdl.Type) error {
+ *t.Value = NFloat64(0)
+ return nil
+}
type NArray2Uint64 [2]uint64
@@ -1531,6 +1740,10 @@
return nil
}
+func (t *NArray2Uint64Target) FromZero(tt *vdl.Type) error {
+ *t.Value = NArray2Uint64{}
+ return nil
+}
type NListUint64 []uint64
@@ -1598,6 +1811,10 @@
return nil
}
+func (t *NListUint64Target) FromZero(tt *vdl.Type) error {
+ *t.Value = NListUint64(nil)
+ return nil
+}
type NSetUint64 map[uint64]struct{}
@@ -1666,6 +1883,10 @@
return nil
}
+func (t *NSetUint64Target) FromZero(tt *vdl.Type) error {
+ *t.Value = NSetUint64(nil)
+ return nil
+}
type NMapUint64String map[uint64]string
@@ -1749,6 +1970,10 @@
return nil
}
+func (t *NMapUint64StringTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = NMapUint64String(nil)
+ return nil
+}
type NStruct struct {
A bool
@@ -1766,40 +1991,63 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.A == false)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.B), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.B == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.B), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("C")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("C")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromInt(int64(m.C), tt.NonOptional().Field(2).Type); err != nil {
- return err
+
+ var10 := (m.C == int64(0))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromInt(int64(m.C), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -1854,6 +2102,10 @@
return nil
}
+func (t *NStructTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = NStruct{}
+ return nil
+}
type NEnum int
@@ -1937,11 +2189,15 @@
case "C":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum v.io/v23/vom/testdata/types.NEnum", src)
+ return fmt.Errorf("label %s not in enum NEnum", src)
}
return nil
}
+func (t *NEnumTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = NEnumA
+ return nil
+}
type (
// NUnion represents any single field of the NUnion union type.
@@ -2114,6 +2370,10 @@
return nil
}
+func (t *NUnionTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = NUnion(NUnionA{})
+ return nil
+}
type nUnionTargetFactory struct{}
@@ -2157,6 +2417,10 @@
return nil
}
+func (t *MBoolTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MBool(false)
+ return nil
+}
type MStruct struct {
A bool
@@ -2177,57 +2441,61 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.A == false)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.B.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("C")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
-
- if err := m.C.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("D")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
-
- if m.D == nil {
- if err := fieldTarget9.FromNil(tt.NonOptional().Field(3).Type); err != nil {
+ var7 := (m.B == NBool(false))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- if err := m.D.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
+
+ if err := m.B.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ return err
+ }
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("C")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var10 := (m.C == MBool(false))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.C.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
return err
}
}
@@ -2235,38 +2503,75 @@
return err
}
}
- keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("E")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- typeObjectVal12 := m.E
- if typeObjectVal12 == nil {
- typeObjectVal12 = vdl.AnyType
- }
- if err := fieldTarget11.FromTypeObject(typeObjectVal12); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
- return err
- }
- }
- keyTarget13, fieldTarget14, err := fieldsTarget1.StartField("F")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("D")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.F == nil {
- if err := fieldTarget14.FromNil(tt.NonOptional().Field(5).Type); err != nil {
+ var13 := (m.D == (*NStruct)(nil))
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
return err
}
} else {
- if err := vdl.FromValue(fieldTarget14, m.F); err != nil {
+
+ if err := m.D.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
return err
}
}
- if err := fieldsTarget1.FinishField(keyTarget13, fieldTarget14); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("E")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var16 := (m.E == vdl.AnyType)
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+ typeObjectVal17 := m.E
+ if typeObjectVal17 == nil {
+ typeObjectVal17 = vdl.AnyType
+ }
+ if err := fieldTarget15.FromTypeObject(typeObjectVal17); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
+ return err
+ }
+ }
+ keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("F")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var20 := (m.F == vdl.ZeroValue(vdl.AnyType))
+ if var20 {
+ if err := fieldTarget19.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if m.F == nil {
+ if err := fieldTarget19.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := vdl.FromValue(fieldTarget19, m.F); err != nil {
+ return err
+ }
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil {
return err
}
}
@@ -2335,6 +2640,13 @@
return nil
}
+func (t *MStructTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MStruct{
+ E: vdl.AnyType,
+ F: vdl.ZeroValue(vdl.AnyType),
+ }
+ return nil
+}
// Optional NStruct
type __VDLTarget7_optional struct {
@@ -2360,10 +2672,8 @@
return nil
}
-func (t *__VDLTarget7_optional) FromNil(tt *vdl.Type) error {
-
- *t.Value = nil
-
+func (t *__VDLTarget7_optional) FromZero(tt *vdl.Type) error {
+ *t.Value = (*NStruct)(nil)
return nil
}
@@ -2434,6 +2744,10 @@
return nil
}
+func (t *MListTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MList(nil)
+ return nil
+}
type MMap map[NFloat32]NListUint64
@@ -2519,6 +2833,10 @@
return nil
}
+func (t *MMapTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MMap(nil)
+ return nil
+}
type MByteSlice []byte
@@ -2557,6 +2875,10 @@
return nil
}
+func (t *MByteSliceTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MByteSlice(nil)
+ return nil
+}
type MInt8Slice []int8
@@ -2624,6 +2946,10 @@
return nil
}
+func (t *MInt8SliceTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MInt8Slice(nil)
+ return nil
+}
// Recursive Type Definitions
type RecA []RecA
@@ -2692,6 +3018,10 @@
return nil
}
+func (t *RecATarget) FromZero(tt *vdl.Type) error {
+ *t.Value = RecA(nil)
+ return nil
+}
type RecY []RecX
@@ -2759,6 +3089,10 @@
return nil
}
+func (t *RecYTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = RecY(nil)
+ return nil
+}
// RecX
type RecXTarget struct {
@@ -2791,6 +3125,10 @@
return nil
}
+func (t *RecXTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = RecX(nil)
+ return nil
+}
type RecX []RecY
@@ -2893,6 +3231,10 @@
return nil
}
+func (t *Rec4Target) FromZero(tt *vdl.Type) error {
+ *t.Value = Rec4(nil)
+ return nil
+}
// Rec1
type Rec1Target struct {
@@ -2925,6 +3267,10 @@
return nil
}
+func (t *Rec1Target) FromZero(tt *vdl.Type) error {
+ *t.Value = Rec1(nil)
+ return nil
+}
// Rec2
type Rec2Target struct {
@@ -2957,6 +3303,10 @@
return nil
}
+func (t *Rec2Target) FromZero(tt *vdl.Type) error {
+ *t.Value = Rec2(nil)
+ return nil
+}
// Rec3
type Rec3Target struct {
@@ -2989,6 +3339,10 @@
return nil
}
+func (t *Rec3Target) FromZero(tt *vdl.Type) error {
+ *t.Value = Rec3(nil)
+ return nil
+}
type Rec3 []Rec4
@@ -3109,18 +3463,19 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.A == nil {
- if err := fieldTarget3.FromNil(tt.NonOptional().Field(0).Type); err != nil {
+ var4 := (m.A == (*RecStruct)(nil))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
return err
}
} else {
+
if err := m.A.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
return err
}
@@ -3169,6 +3524,10 @@
return nil
}
+func (t *RecStructTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = RecStruct{}
+ return nil
+}
// Optional RecStruct
type __VDLTarget8_optional struct {
@@ -3193,10 +3552,8 @@
return nil
}
-func (t *__VDLTarget8_optional) FromNil(tt *vdl.Type) error {
-
- *t.Value = nil
-
+func (t *__VDLTarget8_optional) FromZero(tt *vdl.Type) error {
+ *t.Value = (*RecStruct)(nil)
return nil
}
@@ -3217,59 +3574,102 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("R1")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.R1.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var var4 bool
+ if len(m.R1) == 0 {
+ var4 = true
+ }
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.R1.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("R2")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("R2")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.R2.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var var7 bool
+ if len(m.R2) == 0 {
+ var7 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.R2.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("R3")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("R3")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.R3.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
- return err
+ var var10 bool
+ if len(m.R3) == 0 {
+ var10 = true
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("R4")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
- if err := m.R4.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(3).Type); err != nil {
- return err
+ if err := m.R3.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("R4")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var13 bool
+ if len(m.R4) == 0 {
+ var13 = true
+ }
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.R4.FillVDLTarget(fieldTarget12, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -3326,6 +3726,10 @@
return nil
}
+func (t *Rec1234Target) FromZero(tt *vdl.Type) error {
+ *t.Value = Rec1234{}
+ return nil
+}
type Rec1234A struct {
A []Rec1234A
@@ -3342,64 +3746,85 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget4, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.A))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.A) == 0 {
+ var4 = true
}
- for i, elem6 := range m.A {
- elemTarget5, err := listTarget4.StartElem(i)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget5, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.A))
if err != nil {
return err
}
+ for i, elem7 := range m.A {
+ elemTarget6, err := listTarget5.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem6.FillVDLTarget(elemTarget5, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ if err := elem7.FillVDLTarget(elemTarget6, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget5.FinishElem(elemTarget6); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishList(listTarget5); err != nil {
return err
}
- if err := listTarget4.FinishElem(elemTarget5); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishList(listTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("Rec1234")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Rec1234")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget9, err := fieldTarget8.StartList(tt.NonOptional().Field(1).Type, len(m.Rec1234))
- if err != nil {
- return err
+ var var10 bool
+ if len(m.Rec1234) == 0 {
+ var10 = true
}
- for i, elem11 := range m.Rec1234 {
- elemTarget10, err := listTarget9.StartElem(i)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget11, err := fieldTarget9.StartList(tt.NonOptional().Field(1).Type, len(m.Rec1234))
if err != nil {
return err
}
+ for i, elem13 := range m.Rec1234 {
+ elemTarget12, err := listTarget11.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem11.FillVDLTarget(elemTarget10, tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ if err := elem13.FillVDLTarget(elemTarget12, tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget11.FinishElem(elemTarget12); err != nil {
+ return err
+ }
}
- if err := listTarget9.FinishElem(elemTarget10); err != nil {
+ if err := fieldTarget9.FinishList(listTarget11); err != nil {
return err
}
}
- if err := fieldTarget8.FinishList(listTarget9); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -3448,6 +3873,10 @@
return nil
}
+func (t *Rec1234ATarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Rec1234A{}
+ return nil
+}
// []Rec1234A
type __VDLTarget10_list struct {
@@ -3480,6 +3909,10 @@
return nil
}
+func (t *__VDLTarget10_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []Rec1234A(nil)
+ return nil
+}
// []Rec1234
type __VDLTarget9_list struct {
@@ -3513,6 +3946,10 @@
return nil
}
+func (t *__VDLTarget9_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []Rec1234(nil)
+ return nil
+}
type Rec1234B struct {
B []Rec1234B
@@ -3529,64 +3966,85 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget4, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.B))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.B) == 0 {
+ var4 = true
}
- for i, elem6 := range m.B {
- elemTarget5, err := listTarget4.StartElem(i)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget5, err := fieldTarget3.StartList(tt.NonOptional().Field(0).Type, len(m.B))
if err != nil {
return err
}
+ for i, elem7 := range m.B {
+ elemTarget6, err := listTarget5.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem6.FillVDLTarget(elemTarget5, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ if err := elem7.FillVDLTarget(elemTarget6, tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget5.FinishElem(elemTarget6); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishList(listTarget5); err != nil {
return err
}
- if err := listTarget4.FinishElem(elemTarget5); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishList(listTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("Rec1234")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Rec1234")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget9, err := fieldTarget8.StartList(tt.NonOptional().Field(1).Type, len(m.Rec1234))
- if err != nil {
- return err
+ var var10 bool
+ if len(m.Rec1234) == 0 {
+ var10 = true
}
- for i, elem11 := range m.Rec1234 {
- elemTarget10, err := listTarget9.StartElem(i)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget11, err := fieldTarget9.StartList(tt.NonOptional().Field(1).Type, len(m.Rec1234))
if err != nil {
return err
}
+ for i, elem13 := range m.Rec1234 {
+ elemTarget12, err := listTarget11.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem11.FillVDLTarget(elemTarget10, tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ if err := elem13.FillVDLTarget(elemTarget12, tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget11.FinishElem(elemTarget12); err != nil {
+ return err
+ }
}
- if err := listTarget9.FinishElem(elemTarget10); err != nil {
+ if err := fieldTarget9.FinishList(listTarget11); err != nil {
return err
}
}
- if err := fieldTarget8.FinishList(listTarget9); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -3635,6 +4093,10 @@
return nil
}
+func (t *Rec1234BTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Rec1234B{}
+ return nil
+}
// []Rec1234B
type __VDLTarget11_list struct {
@@ -3667,6 +4129,10 @@
return nil
}
+func (t *__VDLTarget11_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []Rec1234B(nil)
+ return nil
+}
type Rec1234All struct {
A Rec1234A
@@ -3683,30 +4149,65 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.A.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := true
+ var var5 bool
+ if len(m.A.A) == 0 {
+ var5 = true
+ }
+ var4 = var4 && var5
+ var var6 bool
+ if len(m.A.Rec1234) == 0 {
+ var6 = true
+ }
+ var4 = var4 && var6
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.A.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
+ keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.B.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var9 := true
+ var var10 bool
+ if len(m.B.B) == 0 {
+ var10 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ var9 = var9 && var10
+ var var11 bool
+ if len(m.B.Rec1234) == 0 {
+ var11 = true
+ }
+ var9 = var9 && var11
+ if var9 {
+ if err := fieldTarget8.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.B.FillVDLTarget(fieldTarget8, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil {
return err
}
}
@@ -3756,6 +4257,10 @@
return nil
}
+func (t *Rec1234AllTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Rec1234All{}
+ return nil
+}
// Additional types for compatibility and conversion checks
type ListString []string
@@ -3824,6 +4329,10 @@
return nil
}
+func (t *ListStringTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ListString(nil)
+ return nil
+}
type Array3String [3]string
@@ -3886,6 +4395,10 @@
return nil
}
+func (t *Array3StringTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Array3String{}
+ return nil
+}
type Array4String [4]string
@@ -3948,6 +4461,10 @@
return nil
}
+func (t *Array4StringTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Array4String{}
+ return nil
+}
type AbcStruct struct {
A bool
@@ -3965,40 +4482,63 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.A == false)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("B")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("B")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromString(string(m.B), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.B == "")
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromString(string(m.B), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("C")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("C")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromInt(int64(m.C), tt.NonOptional().Field(2).Type); err != nil {
- return err
+
+ var10 := (m.C == int64(0))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromInt(int64(m.C), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -4053,6 +4593,10 @@
return nil
}
+func (t *AbcStructTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = AbcStruct{}
+ return nil
+}
type AdeStruct struct {
A bool
@@ -4070,51 +4614,74 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("A")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.A == false)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromBool(bool(m.A), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("D")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("D")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.D == nil {
- if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
+ var7 := (m.D == vdl.ZeroValue(vdl.AnyType))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- if err := vdl.FromValue(fieldTarget5, m.D); err != nil {
- return err
+
+ if m.D == nil {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := vdl.FromValue(fieldTarget6, m.D); err != nil {
+ return err
+ }
}
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("E")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("E")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- typeObjectVal8 := m.E
- if typeObjectVal8 == nil {
- typeObjectVal8 = vdl.AnyType
+
+ var10 := (m.E == vdl.AnyType)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ typeObjectVal11 := m.E
+ if typeObjectVal11 == nil {
+ typeObjectVal11 = vdl.AnyType
+ }
+ if err := fieldTarget9.FromTypeObject(typeObjectVal11); err != nil {
+ return err
+ }
}
- if err := fieldTarget7.FromTypeObject(typeObjectVal8); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -4168,6 +4735,13 @@
return nil
}
+func (t *AdeStructTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = AdeStruct{
+ D: vdl.ZeroValue(vdl.AnyType),
+ E: vdl.AnyType,
+ }
+ return nil
+}
type XyzStruct struct {
X bool
@@ -4185,41 +4759,64 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("X")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromBool(bool(m.X), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.X == false)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromBool(bool(m.X), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Y")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Y")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Y.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.Y == MBool(false))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Y.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Z")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Z")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromString(string(m.Z), tt.NonOptional().Field(2).Type); err != nil {
- return err
+
+ var10 := (m.Z == "")
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromString(string(m.Z), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -4274,6 +4871,10 @@
return nil
}
+func (t *XyzStructTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = XyzStruct{}
+ return nil
+}
type YzStruct struct {
Y NBool
@@ -4290,30 +4891,45 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Y")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Y.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Y == NBool(false))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Y.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Z")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Z")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Z.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.Z == NString(""))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Z.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -4363,6 +4979,10 @@
return nil
}
+func (t *YzStructTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = YzStruct{}
+ return nil
+}
type ZStruct struct {
Z string
@@ -4378,14 +4998,21 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Z")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Z), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Z == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Z), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -4432,6 +5059,10 @@
return nil
}
+func (t *ZStructTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ZStruct{}
+ return nil
+}
type MapOnlyStruct struct {
Key1 int64
@@ -4448,28 +5079,43 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Key1")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromInt(int64(m.Key1), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Key1 == int64(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromInt(int64(m.Key1), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Key2")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Key2")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromUint(uint64(m.Key2), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Key2 == uint32(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromUint(uint64(m.Key2), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -4519,6 +5165,10 @@
return nil
}
+func (t *MapOnlyStructTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MapOnlyStruct{}
+ return nil
+}
type StructOnlyMap map[string]uint64
@@ -4602,6 +5252,10 @@
return nil
}
+func (t *StructOnlyMapTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = StructOnlyMap(nil)
+ return nil
+}
type MapSetStruct struct {
Feat bool
@@ -4619,40 +5273,63 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Feat")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromBool(bool(m.Feat), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Feat == false)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromBool(bool(m.Feat), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Tire")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Tire")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromBool(bool(m.Tire), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.Tire == false)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromBool(bool(m.Tire), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Eel")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Eel")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromBool(bool(m.Eel), tt.NonOptional().Field(2).Type); err != nil {
- return err
+
+ var10 := (m.Eel == false)
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromBool(bool(m.Eel), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -4707,6 +5384,10 @@
return nil
}
+func (t *MapSetStructTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MapSetStruct{}
+ return nil
+}
type SetStructMap map[string]bool
@@ -4790,6 +5471,10 @@
return nil
}
+func (t *SetStructMapTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SetStructMap(nil)
+ return nil
+}
type MapStructSet map[string]struct{}
@@ -4858,6 +5543,10 @@
return nil
}
+func (t *MapStructSetTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MapStructSet(nil)
+ return nil
+}
type SetOnlyMap map[float64]bool
@@ -4941,6 +5630,10 @@
return nil
}
+func (t *SetOnlyMapTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SetOnlyMap(nil)
+ return nil
+}
type SometimesSetMap map[float64]*vdl.Value
@@ -4968,7 +5661,7 @@
}
if value5 == nil {
- if err := valueTarget4.FromNil(tt.NonOptional().Elem()); err != nil {
+ if err := valueTarget4.FromZero(tt.NonOptional().Elem()); err != nil {
return err
}
} else {
@@ -5015,7 +5708,7 @@
return target, err
}
func (t *SometimesSetMapTarget) FinishKeyStartField(key vdl.Target) (field vdl.Target, _ error) {
- t.currElem = (*vdl.Value)(nil)
+ t.currElem = vdl.ZeroValue(vdl.AnyType)
target, err := vdl.ReflectTarget(reflect.ValueOf(&t.currElem))
return target, err
}
@@ -5030,6 +5723,10 @@
return nil
}
+func (t *SometimesSetMapTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SometimesSetMap(nil)
+ return nil
+}
type MapOnlySet map[float64]struct{}
@@ -5098,6 +5795,10 @@
return nil
}
+func (t *MapOnlySetTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MapOnlySet(nil)
+ return nil
+}
type SetOnlyA map[bool]struct{}
@@ -5166,6 +5867,10 @@
return nil
}
+func (t *SetOnlyATarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SetOnlyA(nil)
+ return nil
+}
type SetOnlyA2 map[NBool]struct{}
@@ -5235,6 +5940,10 @@
return nil
}
+func (t *SetOnlyA2Target) FromZero(tt *vdl.Type) error {
+ *t.Value = SetOnlyA2(nil)
+ return nil
+}
type SetOnlyB map[int16]struct{}
@@ -5303,6 +6012,10 @@
return nil
}
+func (t *SetOnlyBTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SetOnlyB(nil)
+ return nil
+}
type SetOnlyB2 map[NInt16]struct{}
@@ -5372,6 +6085,10 @@
return nil
}
+func (t *SetOnlyB2Target) FromZero(tt *vdl.Type) error {
+ *t.Value = SetOnlyB2(nil)
+ return nil
+}
type MapOnlyA map[uint32]uint32
@@ -5455,6 +6172,10 @@
return nil
}
+func (t *MapOnlyATarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MapOnlyA(nil)
+ return nil
+}
type MapOnlyA2 map[int64]float64
@@ -5538,6 +6259,10 @@
return nil
}
+func (t *MapOnlyA2Target) FromZero(tt *vdl.Type) error {
+ *t.Value = MapOnlyA2(nil)
+ return nil
+}
type MapOnlyB map[bool]string
@@ -5621,6 +6346,10 @@
return nil
}
+func (t *MapOnlyBTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = MapOnlyB(nil)
+ return nil
+}
type MapOnlyB2 map[NBool]NString
@@ -5706,6 +6435,10 @@
return nil
}
+func (t *MapOnlyB2Target) FromZero(tt *vdl.Type) error {
+ *t.Value = MapOnlyB2(nil)
+ return nil
+}
type (
// BdeUnion represents any single field of the BdeUnion union type.
@@ -5786,7 +6519,7 @@
}
if m.Value == nil {
- if err := fieldTarget3.FromNil(tt.NonOptional().Field(1).Type); err != nil {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
@@ -5890,6 +6623,10 @@
return nil
}
+func (t *BdeUnionTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BdeUnion(BdeUnionB{})
+ return nil
+}
type bdeUnionTargetFactory struct{}
@@ -5982,11 +6719,15 @@
case "Three":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum v.io/v23/vom/testdata/types.BrieEnum", src)
+ return fmt.Errorf("label %s not in enum BrieEnum", src)
}
return nil
}
+func (t *BrieEnumTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BrieEnumGlee
+ return nil
+}
type BeanEnum int
@@ -6054,11 +6795,15 @@
case "Bean":
*t.Value = 0
default:
- return fmt.Errorf("label %s not in enum v.io/v23/vom/testdata/types.BeanEnum", src)
+ return fmt.Errorf("label %s not in enum BeanEnum", src)
}
return nil
}
+func (t *BeanEnumTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = BeanEnumBean
+ return nil
+}
type FoodEnum int
@@ -6142,11 +6887,15 @@
case "Cherry":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum v.io/v23/vom/testdata/types.FoodEnum", src)
+ return fmt.Errorf("label %s not in enum FoodEnum", src)
}
return nil
}
+func (t *FoodEnumTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = FoodEnumBean
+ return nil
+}
type StructAny struct {
Any *vdl.Value
@@ -6162,20 +6911,27 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Any")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.Any == nil {
- if err := fieldTarget3.FromNil(tt.NonOptional().Field(0).Type); err != nil {
+ var4 := (m.Any == vdl.ZeroValue(vdl.AnyType))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
return err
}
} else {
- if err := vdl.FromValue(fieldTarget3, m.Any); err != nil {
- return err
+
+ if m.Any == nil {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := vdl.FromValue(fieldTarget3, m.Any); err != nil {
+ return err
+ }
}
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
@@ -6222,6 +6978,12 @@
return nil
}
+func (t *StructAnyTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = StructAny{
+ Any: vdl.ZeroValue(vdl.AnyType),
+ }
+ return nil
+}
type StructMap struct {
Map map[int64]int64
@@ -6237,38 +6999,48 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Map")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- mapTarget4, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.Map))
- if err != nil {
- return err
+ var var4 bool
+ if len(m.Map) == 0 {
+ var4 = true
}
- for key6, value8 := range m.Map {
- keyTarget5, err := mapTarget4.StartKey()
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ mapTarget5, err := fieldTarget3.StartMap(tt.NonOptional().Field(0).Type, len(m.Map))
if err != nil {
return err
}
- if err := keyTarget5.FromInt(int64(key6), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ for key7, value9 := range m.Map {
+ keyTarget6, err := mapTarget5.StartKey()
+ if err != nil {
+ return err
+ }
+ if err := keyTarget6.FromInt(int64(key7), tt.NonOptional().Field(0).Type.Key()); err != nil {
+ return err
+ }
+ valueTarget8, err := mapTarget5.FinishKeyStartField(keyTarget6)
+ if err != nil {
+ return err
+ }
+ if err := valueTarget8.FromInt(int64(value9), tt.NonOptional().Field(0).Type.Elem()); err != nil {
+ return err
+ }
+ if err := mapTarget5.FinishField(keyTarget6, valueTarget8); err != nil {
+ return err
+ }
+ }
+ if err := fieldTarget3.FinishMap(mapTarget5); err != nil {
return err
}
- valueTarget7, err := mapTarget4.FinishKeyStartField(keyTarget5)
- if err != nil {
- return err
- }
- if err := valueTarget7.FromInt(int64(value8), tt.NonOptional().Field(0).Type.Elem()); err != nil {
- return err
- }
- if err := mapTarget4.FinishField(keyTarget5, valueTarget7); err != nil {
- return err
- }
- }
- if err := fieldTarget3.FinishMap(mapTarget4); err != nil {
- return err
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
@@ -6315,6 +7087,10 @@
return nil
}
+func (t *StructMapTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = StructMap{}
+ return nil
+}
// map[int64]int64
type __VDLTarget12_map struct {
@@ -6358,6 +7134,10 @@
return nil
}
+func (t *__VDLTarget12_map) FromZero(tt *vdl.Type) error {
+ *t.Value = map[int64]int64(nil)
+ return nil
+}
// Since the encoding changes if struct fields are zero values,
// test each of the kinds in a struct both as zero and non-zero values.
@@ -6396,286 +7176,478 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Bool")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromBool(bool(m.Bool), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Bool == false)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromBool(bool(m.Bool), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("AByte")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("AByte")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromUint(uint64(m.AByte), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var7 := (m.AByte == byte(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget6.FromUint(uint64(m.AByte), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Int16")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Int16")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromInt(int64(m.Int16), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Int32")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget9.FromInt(int64(m.Int32), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var10 := (m.Int16 == int16(0))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromInt(int64(m.Int16), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("Int64")
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("Int32")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget11.FromInt(int64(m.Int64), tt.NonOptional().Field(4).Type); err != nil {
- return err
+
+ var13 := (m.Int32 == int32(0))
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget12.FromInt(int64(m.Int32), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
return err
}
}
- keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("Uint16")
+ keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Int64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget13.FromUint(uint64(m.Uint16), tt.NonOptional().Field(5).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
- return err
- }
- }
- keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Uint32")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget15.FromUint(uint64(m.Uint32), tt.NonOptional().Field(6).Type); err != nil {
- return err
+
+ var16 := (m.Int64 == int64(0))
+ if var16 {
+ if err := fieldTarget15.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget15.FromInt(int64(m.Int64), tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
return err
}
}
- keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("Uint64")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget17.FromUint(uint64(m.Uint64), tt.NonOptional().Field(7).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
- return err
- }
- }
- keyTarget18, fieldTarget19, err := fieldsTarget1.StartField("String")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget19.FromString(string(m.String), tt.NonOptional().Field(8).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget18, fieldTarget19); err != nil {
- return err
- }
- }
- keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("Bytes")
+ keyTarget17, fieldTarget18, err := fieldsTarget1.StartField("Uint16")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget21.FromBytes([]byte(m.Bytes), tt.NonOptional().Field(9).Type); err != nil {
+ var19 := (m.Uint16 == uint16(0))
+ if var19 {
+ if err := fieldTarget18.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget18.FromUint(uint64(m.Uint16), tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget17, fieldTarget18); err != nil {
return err
}
+ }
+ keyTarget20, fieldTarget21, err := fieldsTarget1.StartField("Uint32")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var22 := (m.Uint32 == uint32(0))
+ if var22 {
+ if err := fieldTarget21.FromZero(tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget21.FromUint(uint64(m.Uint32), tt.NonOptional().Field(6).Type); err != nil {
+ return err
+ }
+ }
if err := fieldsTarget1.FinishField(keyTarget20, fieldTarget21); err != nil {
return err
}
}
- keyTarget22, fieldTarget23, err := fieldsTarget1.StartField("Float32")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget23.FromFloat(float64(m.Float32), tt.NonOptional().Field(10).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget22, fieldTarget23); err != nil {
- return err
- }
- }
- keyTarget24, fieldTarget25, err := fieldsTarget1.StartField("Float64")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget25.FromFloat(float64(m.Float64), tt.NonOptional().Field(11).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget24, fieldTarget25); err != nil {
- return err
- }
- }
- keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("FoodEnum")
+ keyTarget23, fieldTarget24, err := fieldsTarget1.StartField("Uint64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.FoodEnum.FillVDLTarget(fieldTarget27, tt.NonOptional().Field(12).Type); err != nil {
+ var25 := (m.Uint64 == uint64(0))
+ if var25 {
+ if err := fieldTarget24.FromZero(tt.NonOptional().Field(7).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget24.FromUint(uint64(m.Uint64), tt.NonOptional().Field(7).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget23, fieldTarget24); err != nil {
return err
}
+ }
+ keyTarget26, fieldTarget27, err := fieldsTarget1.StartField("String")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var28 := (m.String == "")
+ if var28 {
+ if err := fieldTarget27.FromZero(tt.NonOptional().Field(8).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget27.FromString(string(m.String), tt.NonOptional().Field(8).Type); err != nil {
+ return err
+ }
+ }
if err := fieldsTarget1.FinishField(keyTarget26, fieldTarget27); err != nil {
return err
}
}
- keyTarget28, fieldTarget29, err := fieldsTarget1.StartField("NEnum")
+ keyTarget29, fieldTarget30, err := fieldsTarget1.StartField("Bytes")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.NEnum.FillVDLTarget(fieldTarget29, tt.NonOptional().Field(13).Type); err != nil {
- return err
+ var var31 bool
+ if len(m.Bytes) == 0 {
+ var31 = true
}
- if err := fieldsTarget1.FinishField(keyTarget28, fieldTarget29); err != nil {
+ if var31 {
+ if err := fieldTarget30.FromZero(tt.NonOptional().Field(9).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget30.FromBytes([]byte(m.Bytes), tt.NonOptional().Field(9).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget29, fieldTarget30); err != nil {
return err
}
}
- keyTarget30, fieldTarget31, err := fieldsTarget1.StartField("NListUint64")
+ keyTarget32, fieldTarget33, err := fieldsTarget1.StartField("Float32")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.NListUint64.FillVDLTarget(fieldTarget31, tt.NonOptional().Field(14).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget30, fieldTarget31); err != nil {
- return err
- }
- }
- keyTarget32, fieldTarget33, err := fieldsTarget1.StartField("NByteArray")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
-
- if err := m.NByteArray.FillVDLTarget(fieldTarget33, tt.NonOptional().Field(15).Type); err != nil {
- return err
+ var34 := (m.Float32 == float32(0))
+ if var34 {
+ if err := fieldTarget33.FromZero(tt.NonOptional().Field(10).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget33.FromFloat(float64(m.Float32), tt.NonOptional().Field(10).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget32, fieldTarget33); err != nil {
return err
}
}
- keyTarget34, fieldTarget35, err := fieldsTarget1.StartField("NArray2Uint64")
+ keyTarget35, fieldTarget36, err := fieldsTarget1.StartField("Float64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.NArray2Uint64.FillVDLTarget(fieldTarget35, tt.NonOptional().Field(16).Type); err != nil {
- return err
+ var37 := (m.Float64 == float64(0))
+ if var37 {
+ if err := fieldTarget36.FromZero(tt.NonOptional().Field(11).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget36.FromFloat(float64(m.Float64), tt.NonOptional().Field(11).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget34, fieldTarget35); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget35, fieldTarget36); err != nil {
return err
}
}
- keyTarget36, fieldTarget37, err := fieldsTarget1.StartField("NSetUint64")
+ keyTarget38, fieldTarget39, err := fieldsTarget1.StartField("FoodEnum")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.NSetUint64.FillVDLTarget(fieldTarget37, tt.NonOptional().Field(17).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget36, fieldTarget37); err != nil {
- return err
- }
- }
- keyTarget38, fieldTarget39, err := fieldsTarget1.StartField("NMapUint64String")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
+ var40 := (m.FoodEnum == FoodEnumBean)
+ if var40 {
+ if err := fieldTarget39.FromZero(tt.NonOptional().Field(12).Type); err != nil {
+ return err
+ }
+ } else {
- if err := m.NMapUint64String.FillVDLTarget(fieldTarget39, tt.NonOptional().Field(18).Type); err != nil {
- return err
+ if err := m.FoodEnum.FillVDLTarget(fieldTarget39, tt.NonOptional().Field(12).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget38, fieldTarget39); err != nil {
return err
}
}
- keyTarget40, fieldTarget41, err := fieldsTarget1.StartField("NStruct")
+ keyTarget41, fieldTarget42, err := fieldsTarget1.StartField("NEnum")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.NStruct.FillVDLTarget(fieldTarget41, tt.NonOptional().Field(19).Type); err != nil {
- return err
+ var43 := (m.NEnum == NEnumA)
+ if var43 {
+ if err := fieldTarget42.FromZero(tt.NonOptional().Field(13).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.NEnum.FillVDLTarget(fieldTarget42, tt.NonOptional().Field(13).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget40, fieldTarget41); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget41, fieldTarget42); err != nil {
return err
}
}
- keyTarget42, fieldTarget43, err := fieldsTarget1.StartField("NUnion")
+ keyTarget44, fieldTarget45, err := fieldsTarget1.StartField("NListUint64")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- unionValue44 := m.NUnion
- if unionValue44 == nil {
- unionValue44 = NUnionA{}
+ var var46 bool
+ if len(m.NListUint64) == 0 {
+ var46 = true
}
- if err := unionValue44.FillVDLTarget(fieldTarget43, tt.NonOptional().Field(20).Type); err != nil {
- return err
+ if var46 {
+ if err := fieldTarget45.FromZero(tt.NonOptional().Field(14).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.NListUint64.FillVDLTarget(fieldTarget45, tt.NonOptional().Field(14).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget42, fieldTarget43); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget44, fieldTarget45); err != nil {
return err
}
}
- keyTarget45, fieldTarget46, err := fieldsTarget1.StartField("TypeObject")
+ keyTarget47, fieldTarget48, err := fieldsTarget1.StartField("NByteArray")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- typeObjectVal47 := m.TypeObject
- if typeObjectVal47 == nil {
- typeObjectVal47 = vdl.AnyType
+
+ var49 := (m.NByteArray == NByteArray{})
+ if var49 {
+ if err := fieldTarget48.FromZero(tt.NonOptional().Field(15).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.NByteArray.FillVDLTarget(fieldTarget48, tt.NonOptional().Field(15).Type); err != nil {
+ return err
+ }
}
- if err := fieldTarget46.FromTypeObject(typeObjectVal47); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget47, fieldTarget48); err != nil {
return err
}
- if err := fieldsTarget1.FinishField(keyTarget45, fieldTarget46); err != nil {
+ }
+ keyTarget50, fieldTarget51, err := fieldsTarget1.StartField("NArray2Uint64")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var52 := (m.NArray2Uint64 == NArray2Uint64{})
+ if var52 {
+ if err := fieldTarget51.FromZero(tt.NonOptional().Field(16).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.NArray2Uint64.FillVDLTarget(fieldTarget51, tt.NonOptional().Field(16).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget50, fieldTarget51); err != nil {
+ return err
+ }
+ }
+ keyTarget53, fieldTarget54, err := fieldsTarget1.StartField("NSetUint64")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var55 bool
+ if len(m.NSetUint64) == 0 {
+ var55 = true
+ }
+ if var55 {
+ if err := fieldTarget54.FromZero(tt.NonOptional().Field(17).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.NSetUint64.FillVDLTarget(fieldTarget54, tt.NonOptional().Field(17).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget53, fieldTarget54); err != nil {
+ return err
+ }
+ }
+ keyTarget56, fieldTarget57, err := fieldsTarget1.StartField("NMapUint64String")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var58 bool
+ if len(m.NMapUint64String) == 0 {
+ var58 = true
+ }
+ if var58 {
+ if err := fieldTarget57.FromZero(tt.NonOptional().Field(18).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.NMapUint64String.FillVDLTarget(fieldTarget57, tt.NonOptional().Field(18).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget56, fieldTarget57); err != nil {
+ return err
+ }
+ }
+ keyTarget59, fieldTarget60, err := fieldsTarget1.StartField("NStruct")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var61 := (m.NStruct == NStruct{})
+ if var61 {
+ if err := fieldTarget60.FromZero(tt.NonOptional().Field(19).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.NStruct.FillVDLTarget(fieldTarget60, tt.NonOptional().Field(19).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget59, fieldTarget60); err != nil {
+ return err
+ }
+ }
+ keyTarget62, fieldTarget63, err := fieldsTarget1.StartField("NUnion")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var64 bool
+ if field, ok := m.NUnion.(NUnionA); ok {
+
+ var65 := (field.Value == false)
+ var64 = var65
+ }
+ if var64 {
+ if err := fieldTarget63.FromZero(tt.NonOptional().Field(20).Type); err != nil {
+ return err
+ }
+ } else {
+
+ unionValue66 := m.NUnion
+ if unionValue66 == nil {
+ unionValue66 = NUnionA{}
+ }
+ if err := unionValue66.FillVDLTarget(fieldTarget63, tt.NonOptional().Field(20).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget62, fieldTarget63); err != nil {
+ return err
+ }
+ }
+ keyTarget67, fieldTarget68, err := fieldsTarget1.StartField("TypeObject")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var69 := (m.TypeObject == vdl.AnyType)
+ if var69 {
+ if err := fieldTarget68.FromZero(tt.NonOptional().Field(21).Type); err != nil {
+ return err
+ }
+ } else {
+ typeObjectVal70 := m.TypeObject
+ if typeObjectVal70 == nil {
+ typeObjectVal70 = vdl.AnyType
+ }
+ if err := fieldTarget68.FromTypeObject(typeObjectVal70); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget67, fieldTarget68); err != nil {
return err
}
}
@@ -6825,6 +7797,13 @@
return nil
}
+func (t *StructManyTypesTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = StructManyTypes{
+ NUnion: NUnionA{},
+ TypeObject: vdl.AnyType,
+ }
+ return nil
+}
type AnySlice []*vdl.Value
@@ -6845,7 +7824,7 @@
}
if elem3 == nil {
- if err := elemTarget2.FromNil(tt.NonOptional().Elem()); err != nil {
+ if err := elemTarget2.FromZero(tt.NonOptional().Elem()); err != nil {
return err
}
} else {
@@ -6898,6 +7877,10 @@
return nil
}
+func (t *AnySliceTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = AnySlice(nil)
+ return nil
+}
type LargeMessageType struct {
Payload []byte
@@ -6914,36 +7897,48 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Payload")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromBytes([]byte(m.Payload), tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var var4 bool
+ if len(m.Payload) == 0 {
+ var4 = true
+ }
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget3.FromBytes([]byte(m.Payload), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Next")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Next")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.Next == nil {
- if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
+ var7 := (m.Next == (*LargeMessageType)(nil))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- if err := m.Next.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
+
+ if err := m.Next.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
return err
}
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -6992,6 +7987,10 @@
return nil
}
+func (t *LargeMessageTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = LargeMessageType{}
+ return nil
+}
// Optional LargeMessageType
type __VDLTarget13_optional struct {
@@ -7016,10 +8015,8 @@
return nil
}
-func (t *__VDLTarget13_optional) FromNil(tt *vdl.Type) error {
-
- *t.Value = nil
-
+func (t *__VDLTarget13_optional) FromZero(tt *vdl.Type) error {
+ *t.Value = (*LargeMessageType)(nil)
return nil
}
@@ -7038,42 +8035,51 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Payload")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.Payload == nil {
- if err := fieldTarget3.FromNil(tt.NonOptional().Field(0).Type); err != nil {
+ var4 := (m.Payload == vdl.ZeroValue(vdl.AnyType))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
return err
}
} else {
- if err := vdl.FromValue(fieldTarget3, m.Payload); err != nil {
- return err
+
+ if m.Payload == nil {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := vdl.FromValue(fieldTarget3, m.Payload); err != nil {
+ return err
+ }
}
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Next")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Next")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if m.Next == nil {
- if err := fieldTarget5.FromNil(tt.NonOptional().Field(1).Type); err != nil {
+ var7 := (m.Next == (*LargeAnyMessageType)(nil))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
return err
}
} else {
- if err := m.Next.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
+
+ if err := m.Next.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
return err
}
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -7120,6 +8126,12 @@
return nil
}
+func (t *LargeAnyMessageTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = LargeAnyMessageType{
+ Payload: vdl.ZeroValue(vdl.AnyType),
+ }
+ return nil
+}
// Optional LargeAnyMessageType
type __VDLTarget14_optional struct {
@@ -7132,7 +8144,9 @@
func (t *__VDLTarget14_optional) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
if *t.Value == nil {
- *t.Value = &LargeAnyMessageType{}
+ *t.Value = &LargeAnyMessageType{
+ Payload: vdl.ZeroValue(vdl.AnyType),
+ }
}
target, err := &LargeAnyMessageTypeTarget{Value: *t.Value}, error(nil)
if err != nil {
@@ -7144,102 +8158,11 @@
return nil
}
-func (t *__VDLTarget14_optional) FromNil(tt *vdl.Type) error {
-
- *t.Value = nil
-
+func (t *__VDLTarget14_optional) FromZero(tt *vdl.Type) error {
+ *t.Value = (*LargeAnyMessageType)(nil)
return nil
}
-// Create zero values for each type.
-var (
- __VDLZeroTestCase = TestCase{}
- __VDLZeroConvertGroup = ConvertGroup{
- PrimaryType: vdl.AnyType,
- }
- __VDLZeroVomdataStruct = VomdataStruct{}
- __VDLZeroNBool = NBool(false)
- __VDLZeroNString = NString("")
- __VDLZeroNByteSlice = NByteSlice(nil)
- __VDLZeroNByteArray = NByteArray{}
- __VDLZeroNByte = NByte(0)
- __VDLZeroNUint16 = NUint16(0)
- __VDLZeroNUint32 = NUint32(0)
- __VDLZeroNUint64 = NUint64(0)
- __VDLZeroNInt8 = NInt8(0)
- __VDLZeroNInt16 = NInt16(0)
- __VDLZeroNInt32 = NInt32(0)
- __VDLZeroNInt64 = NInt64(0)
- __VDLZeroNFloat32 = NFloat32(0)
- __VDLZeroNFloat64 = NFloat64(0)
- __VDLZeroNArray2Uint64 = NArray2Uint64{}
- __VDLZeroNListUint64 = NListUint64(nil)
- __VDLZeroNSetUint64 = NSetUint64(nil)
- __VDLZeroNMapUint64String = NMapUint64String(nil)
- __VDLZeroNStruct = NStruct{}
- __VDLZeroNEnum = NEnumA
- __VDLZeroNUnion = NUnion(NUnionA{})
- __VDLZeroMBool = MBool(false)
- __VDLZeroMStruct = MStruct{
- E: vdl.AnyType,
- }
- __VDLZeroMList = MList(nil)
- __VDLZeroMMap = MMap(nil)
- __VDLZeroMByteSlice = MByteSlice(nil)
- __VDLZeroMInt8Slice = MInt8Slice(nil)
- __VDLZeroRecA = RecA(nil)
- __VDLZeroRecY = RecY(nil)
- __VDLZeroRecX = RecX(nil)
- __VDLZeroRec4 = Rec4(nil)
- __VDLZeroRec3 = Rec3(nil)
- __VDLZeroRec2 = Rec2(nil)
- __VDLZeroRec1 = Rec1(nil)
- __VDLZeroRecStruct = RecStruct{}
- __VDLZeroRec1234 = Rec1234{}
- __VDLZeroRec1234A = Rec1234A{}
- __VDLZeroRec1234B = Rec1234B{}
- __VDLZeroRec1234All = Rec1234All{}
- __VDLZeroListString = ListString(nil)
- __VDLZeroArray3String = Array3String{}
- __VDLZeroArray4String = Array4String{}
- __VDLZeroAbcStruct = AbcStruct{}
- __VDLZeroAdeStruct = AdeStruct{
- E: vdl.AnyType,
- }
- __VDLZeroXyzStruct = XyzStruct{}
- __VDLZeroYzStruct = YzStruct{}
- __VDLZeroZStruct = ZStruct{}
- __VDLZeroMapOnlyStruct = MapOnlyStruct{}
- __VDLZeroStructOnlyMap = StructOnlyMap(nil)
- __VDLZeroMapSetStruct = MapSetStruct{}
- __VDLZeroSetStructMap = SetStructMap(nil)
- __VDLZeroMapStructSet = MapStructSet(nil)
- __VDLZeroSetOnlyMap = SetOnlyMap(nil)
- __VDLZeroSometimesSetMap = SometimesSetMap(nil)
- __VDLZeroMapOnlySet = MapOnlySet(nil)
- __VDLZeroSetOnlyA = SetOnlyA(nil)
- __VDLZeroSetOnlyA2 = SetOnlyA2(nil)
- __VDLZeroSetOnlyB = SetOnlyB(nil)
- __VDLZeroSetOnlyB2 = SetOnlyB2(nil)
- __VDLZeroMapOnlyA = MapOnlyA(nil)
- __VDLZeroMapOnlyA2 = MapOnlyA2(nil)
- __VDLZeroMapOnlyB = MapOnlyB(nil)
- __VDLZeroMapOnlyB2 = MapOnlyB2(nil)
- __VDLZeroBdeUnion = BdeUnion(BdeUnionB{})
- __VDLZeroBrieEnum = BrieEnumGlee
- __VDLZeroBeanEnum = BeanEnumBean
- __VDLZeroFoodEnum = FoodEnumBean
- __VDLZeroStructAny = StructAny{}
- __VDLZeroStructMap = StructMap{}
- __VDLZeroStructManyTypes = StructManyTypes{
- NUnion: NUnionA{},
- TypeObject: vdl.AnyType,
- }
- __VDLZeroAnySlice = AnySlice(nil)
- __VDLZeroLargeMessageType = LargeMessageType{}
- __VDLZeroLargeAnyMessageType = LargeAnyMessageType{}
-)
-
var __VDLInitCalled bool
// __VDLInit performs vdl initialization. It is safe to call multiple times.
@@ -7259,6 +8182,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*TestCase)(nil))
diff --git a/vom/testutil_test.go b/vom/testutil_test.go
index 6e69892..f7c95be 100644
--- a/vom/testutil_test.go
+++ b/vom/testutil_test.go
@@ -256,6 +256,9 @@
if value == nil {
return nil, nil
}
+ if value.Kind() == vdl.Any {
+ return nil, nil
+ }
rt := vdl.TypeToReflect(value.Type())
if rt == nil {
return reflect.Value{}, fmt.Errorf("TypeToReflect(%v) failed", value.Type())
diff --git a/vom/vom.vdl.go b/vom/vom.vdl.go
index d6d14ca..d07b7bc 100644
--- a/vom/vom.vdl.go
+++ b/vom/vom.vdl.go
@@ -101,11 +101,15 @@
case "IncompleteType":
*t.Value = 2
default:
- return fmt.Errorf("label %s not in enum v.io/v23/vom.ControlKind", src)
+ return fmt.Errorf("label %s not in enum ControlKind", src)
}
return nil
}
+func (t *ControlKindTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = ControlKindNil
+ return nil
+}
type (
// Primitive represents any single field of the Primitive union type.
@@ -438,6 +442,10 @@
return nil
}
+func (t *PrimitiveTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Primitive(PrimitivePBool{})
+ return nil
+}
type primitiveTargetFactory struct{}
@@ -627,11 +635,15 @@
case "WireTypeIndex":
*t.Value = 14
default:
- return fmt.Errorf("label %s not in enum v.io/v23/vom.DumpKind", src)
+ return fmt.Errorf("label %s not in enum DumpKind", src)
}
return nil
}
+func (t *DumpKindTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = DumpKindVersion
+ return nil
+}
// DumpAtom describes a single indivisible piece of the vom encoding. The vom
// encoding is composed of a stream of these atoms.
@@ -652,59 +664,98 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Kind")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Kind.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Kind == DumpKindVersion)
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Kind.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Bytes")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Bytes")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget5.FromBytes([]byte(m.Bytes), tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var var7 bool
+ if len(m.Bytes) == 0 {
+ var7 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := fieldTarget6.FromBytes([]byte(m.Bytes), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Data")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Data")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- unionValue8 := m.Data
- if unionValue8 == nil {
- unionValue8 = PrimitivePBool{}
+ var var10 bool
+ if field, ok := m.Data.(PrimitivePBool); ok {
+
+ var11 := (field.Value == false)
+ var10 = var11
}
- if err := unionValue8.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
- return err
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ unionValue12 := m.Data
+ if unionValue12 == nil {
+ unionValue12 = PrimitivePBool{}
+ }
+ if err := unionValue12.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Debug")
+ keyTarget13, fieldTarget14, err := fieldsTarget1.StartField("Debug")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget10.FromString(string(m.Debug), tt.NonOptional().Field(3).Type); err != nil {
- return err
+
+ var15 := (m.Debug == "")
+ if var15 {
+ if err := fieldTarget14.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget14.FromString(string(m.Debug), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget13, fieldTarget14); err != nil {
return err
}
}
@@ -764,6 +815,12 @@
return nil
}
+func (t *DumpAtomTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = DumpAtom{
+ Data: PrimitivePBool{},
+ }
+ return nil
+}
// typeId uniquely identifies a type definition within a vom stream.
type typeId uint64
@@ -815,6 +872,10 @@
return nil
}
+func (t *typeIdTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = typeId(0)
+ return nil
+}
// wireNamed represents a type definition for named primitives.
type wireNamed struct {
@@ -832,29 +893,44 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Base")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Base")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Base.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.Base == typeId(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Base.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -904,6 +980,10 @@
return nil
}
+func (t *wireNamedTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = wireNamed{}
+ return nil
+}
// wireEnum represents an type definition for enum types.
type wireEnum struct {
@@ -921,45 +1001,63 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Labels")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Labels")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget6, err := fieldTarget5.StartList(tt.NonOptional().Field(1).Type, len(m.Labels))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.Labels) == 0 {
+ var7 = true
}
- for i, elem8 := range m.Labels {
- elemTarget7, err := listTarget6.StartElem(i)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.Labels))
if err != nil {
return err
}
- if err := elemTarget7.FromString(string(elem8), tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ for i, elem10 := range m.Labels {
+ elemTarget9, err := listTarget8.StartElem(i)
+ if err != nil {
+ return err
+ }
+ if err := elemTarget9.FromString(string(elem10), tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ return err
+ }
}
- if err := listTarget6.FinishElem(elemTarget7); err != nil {
+ if err := fieldTarget6.FinishList(listTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishList(listTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1009,6 +1107,10 @@
return nil
}
+func (t *wireEnumTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = wireEnum{}
+ return nil
+}
// wireArray represents an type definition for array types.
type wireArray struct {
@@ -1027,41 +1129,64 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Elem")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Elem")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Elem.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.Elem == typeId(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Elem.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Len")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Len")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromUint(uint64(m.Len), tt.NonOptional().Field(2).Type); err != nil {
- return err
+
+ var10 := (m.Len == uint64(0))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromUint(uint64(m.Len), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -1116,6 +1241,10 @@
return nil
}
+func (t *wireArrayTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = wireArray{}
+ return nil
+}
// wireList represents a type definition for list types.
type wireList struct {
@@ -1133,29 +1262,44 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Elem")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Elem")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Elem.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.Elem == typeId(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Elem.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1205,6 +1349,10 @@
return nil
}
+func (t *wireListTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = wireList{}
+ return nil
+}
// wireSet represents a type definition for set types.
type wireSet struct {
@@ -1222,29 +1370,44 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Key")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Key")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Key.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.Key == typeId(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Key.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1294,6 +1457,10 @@
return nil
}
+func (t *wireSetTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = wireSet{}
+ return nil
+}
// wireMap represents a type definition for map types.
type wireMap struct {
@@ -1312,42 +1479,65 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Key")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Key")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Key.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.Key == typeId(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Key.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Elem")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Elem")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Elem.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
- return err
+ var10 := (m.Elem == typeId(0))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Elem.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
@@ -1402,6 +1592,10 @@
return nil
}
+func (t *wireMapTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = wireMap{}
+ return nil
+}
// wireField represents a field in a struct or union type.
type wireField struct {
@@ -1419,29 +1613,44 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Type")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Type")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Type.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.Type == typeId(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Type.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1491,6 +1700,10 @@
return nil
}
+func (t *wireFieldTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = wireField{}
+ return nil
+}
// wireStruct represents a type definition for struct types.
type wireStruct struct {
@@ -1508,46 +1721,64 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Fields")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Fields")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget6, err := fieldTarget5.StartList(tt.NonOptional().Field(1).Type, len(m.Fields))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.Fields) == 0 {
+ var7 = true
}
- for i, elem8 := range m.Fields {
- elemTarget7, err := listTarget6.StartElem(i)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.Fields))
if err != nil {
return err
}
+ for i, elem10 := range m.Fields {
+ elemTarget9, err := listTarget8.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem8.FillVDLTarget(elemTarget7, tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ return err
+ }
}
- if err := listTarget6.FinishElem(elemTarget7); err != nil {
+ if err := fieldTarget6.FinishList(listTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishList(listTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1597,6 +1828,10 @@
return nil
}
+func (t *wireStructTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = wireStruct{}
+ return nil
+}
// []wireField
type __VDLTarget1_list struct {
@@ -1630,6 +1865,10 @@
return nil
}
+func (t *__VDLTarget1_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []wireField(nil)
+ return nil
+}
// wireUnion represents a type definition for union types.
type wireUnion struct {
@@ -1647,46 +1886,64 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Fields")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Fields")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget6, err := fieldTarget5.StartList(tt.NonOptional().Field(1).Type, len(m.Fields))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.Fields) == 0 {
+ var7 = true
}
- for i, elem8 := range m.Fields {
- elemTarget7, err := listTarget6.StartElem(i)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.Fields))
if err != nil {
return err
}
+ for i, elem10 := range m.Fields {
+ elemTarget9, err := listTarget8.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem8.FillVDLTarget(elemTarget7, tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ return err
+ }
}
- if err := listTarget6.FinishElem(elemTarget7); err != nil {
+ if err := fieldTarget6.FinishList(listTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishList(listTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1736,6 +1993,10 @@
return nil
}
+func (t *wireUnionTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = wireUnion{}
+ return nil
+}
// wireOptional represents an type definition for optional types.
type wireOptional struct {
@@ -1753,29 +2014,44 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
- return err
+
+ var4 := (m.Name == "")
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget3.FromString(string(m.Name), tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Elem")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Elem")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Elem.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.Elem == typeId(0))
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Elem.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -1825,6 +2101,10 @@
return nil
}
+func (t *wireOptionalTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = wireOptional{}
+ return nil
+}
type (
// wireType represents any single field of the wireType union type.
@@ -2248,6 +2528,10 @@
return nil
}
+func (t *wireTypeTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = wireType(wireTypeNamedT{})
+ return nil
+}
type wireTypeTargetFactory struct{}
@@ -2258,28 +2542,6 @@
return nil, fmt.Errorf("got %T, want *wireType", union)
}
-// Create zero values for each type.
-var (
- __VDLZeroControlKind = ControlKindNil
- __VDLZeroPrimitive = Primitive(PrimitivePBool{})
- __VDLZeroDumpKind = DumpKindVersion
- __VDLZeroDumpAtom = DumpAtom{
- Data: PrimitivePBool{},
- }
- __VDLZerotypeId = typeId(0)
- __VDLZerowireNamed = wireNamed{}
- __VDLZerowireEnum = wireEnum{}
- __VDLZerowireArray = wireArray{}
- __VDLZerowireList = wireList{}
- __VDLZerowireSet = wireSet{}
- __VDLZerowireMap = wireMap{}
- __VDLZerowireField = wireField{}
- __VDLZerowireStruct = wireStruct{}
- __VDLZerowireUnion = wireUnion{}
- __VDLZerowireOptional = wireOptional{}
- __VDLZerowireType = wireType(wireTypeNamedT{})
-)
-
//////////////////////////////////////////////////
// Const definitions
@@ -2330,6 +2592,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*ControlKind)(nil))
diff --git a/vtrace/.api b/vtrace/.api
index e19ebae..a51deb6 100644
--- a/vtrace/.api
+++ b/vtrace/.api
@@ -16,24 +16,28 @@
pkg vtrace, method (*Annotation) MakeVDLTarget() vdl.Target
pkg vtrace, method (*AnnotationTarget) FinishField(vdl.Target, vdl.Target) error
pkg vtrace, method (*AnnotationTarget) FinishFields(vdl.FieldsTarget) error
+pkg vtrace, method (*AnnotationTarget) FromZero(*vdl.Type) error
pkg vtrace, method (*AnnotationTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vtrace, method (*AnnotationTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vtrace, method (*Request) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vtrace, method (*Request) MakeVDLTarget() vdl.Target
pkg vtrace, method (*RequestTarget) FinishField(vdl.Target, vdl.Target) error
pkg vtrace, method (*RequestTarget) FinishFields(vdl.FieldsTarget) error
+pkg vtrace, method (*RequestTarget) FromZero(*vdl.Type) error
pkg vtrace, method (*RequestTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vtrace, method (*RequestTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vtrace, method (*Response) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vtrace, method (*Response) MakeVDLTarget() vdl.Target
pkg vtrace, method (*ResponseTarget) FinishField(vdl.Target, vdl.Target) error
pkg vtrace, method (*ResponseTarget) FinishFields(vdl.FieldsTarget) error
+pkg vtrace, method (*ResponseTarget) FromZero(*vdl.Type) error
pkg vtrace, method (*ResponseTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vtrace, method (*ResponseTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vtrace, method (*SpanRecord) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vtrace, method (*SpanRecord) MakeVDLTarget() vdl.Target
pkg vtrace, method (*SpanRecordTarget) FinishField(vdl.Target, vdl.Target) error
pkg vtrace, method (*SpanRecordTarget) FinishFields(vdl.FieldsTarget) error
+pkg vtrace, method (*SpanRecordTarget) FromZero(*vdl.Type) error
pkg vtrace, method (*SpanRecordTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vtrace, method (*SpanRecordTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vtrace, method (*TraceFlags) FillVDLTarget(vdl.Target, *vdl.Type) error
@@ -41,10 +45,12 @@
pkg vtrace, method (*TraceFlagsTarget) FromFloat(float64, *vdl.Type) error
pkg vtrace, method (*TraceFlagsTarget) FromInt(int64, *vdl.Type) error
pkg vtrace, method (*TraceFlagsTarget) FromUint(uint64, *vdl.Type) error
+pkg vtrace, method (*TraceFlagsTarget) FromZero(*vdl.Type) error
pkg vtrace, method (*TraceRecord) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vtrace, method (*TraceRecord) MakeVDLTarget() vdl.Target
pkg vtrace, method (*TraceRecordTarget) FinishField(vdl.Target, vdl.Target) error
pkg vtrace, method (*TraceRecordTarget) FinishFields(vdl.FieldsTarget) error
+pkg vtrace, method (*TraceRecordTarget) FromZero(*vdl.Type) error
pkg vtrace, method (*TraceRecordTarget) StartField(string) (vdl.Target, vdl.Target, error)
pkg vtrace, method (*TraceRecordTarget) StartFields(*vdl.Type) (vdl.FieldsTarget, error)
pkg vtrace, type Annotation struct
diff --git a/vtrace/vtrace.vdl.go b/vtrace/vtrace.vdl.go
index 6da4b89..bfcd72b 100644
--- a/vtrace/vtrace.vdl.go
+++ b/vtrace/vtrace.vdl.go
@@ -41,7 +41,6 @@
if err != nil {
return err
}
-
var wireValue2 time_2.Time
if err := time_2.TimeFromNative(&wireValue2, m.When); err != nil {
return err
@@ -53,22 +52,38 @@
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue2.FillVDLTarget(fieldTarget4, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var5 := (wireValue2 == time_2.Time{})
+ if var5 {
+ if err := fieldTarget4.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue2.FillVDLTarget(fieldTarget4, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget3, fieldTarget4); err != nil {
return err
}
}
- keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Message")
+ keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Message")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := fieldTarget6.FromString(string(m.Message), tt.NonOptional().Field(1).Type); err != nil {
- return err
+
+ var8 := (m.Message == "")
+ if var8 {
+ if err := fieldTarget7.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget7.FromString(string(m.Message), tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
return err
}
}
@@ -118,6 +133,10 @@
return nil
}
+func (t *AnnotationTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Annotation{}
+ return nil
+}
// A SpanRecord is the wire format for a Span.
type SpanRecord struct {
@@ -140,108 +159,158 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Id")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Id.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Id == uniqueid.Id{})
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Id.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Parent")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Parent")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Parent.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
- return err
- }
- }
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Name")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget7.FromString(string(m.Name), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- var wireValue8 time_2.Time
- if err := time_2.TimeFromNative(&wireValue8, m.Start); err != nil {
- return err
- }
+ var7 := (m.Parent == uniqueid.Id{})
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Start")
+ if err := m.Parent.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
+ return err
+ }
+ }
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Name")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue8.FillVDLTarget(fieldTarget10, tt.NonOptional().Field(3).Type); err != nil {
- return err
+ var10 := (m.Name == "")
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget9.FromString(string(m.Name), tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
var wireValue11 time_2.Time
- if err := time_2.TimeFromNative(&wireValue11, m.End); err != nil {
+ if err := time_2.TimeFromNative(&wireValue11, m.Start); err != nil {
return err
}
- keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("End")
+ keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("Start")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := wireValue11.FillVDLTarget(fieldTarget13, tt.NonOptional().Field(4).Type); err != nil {
- return err
+ var14 := (wireValue11 == time_2.Time{})
+ if var14 {
+ if err := fieldTarget13.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue11.FillVDLTarget(fieldTarget13, tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget12, fieldTarget13); err != nil {
return err
}
}
- keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Annotations")
+ var wireValue15 time_2.Time
+ if err := time_2.TimeFromNative(&wireValue15, m.End); err != nil {
+ return err
+ }
+
+ keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("End")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget16, err := fieldTarget15.StartList(tt.NonOptional().Field(5).Type, len(m.Annotations))
- if err != nil {
+ var18 := (wireValue15 == time_2.Time{})
+ if var18 {
+ if err := fieldTarget17.FromZero(tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := wireValue15.FillVDLTarget(fieldTarget17, tt.NonOptional().Field(4).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget16, fieldTarget17); err != nil {
return err
}
- for i, elem18 := range m.Annotations {
- elemTarget17, err := listTarget16.StartElem(i)
+ }
+ keyTarget19, fieldTarget20, err := fieldsTarget1.StartField("Annotations")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var var21 bool
+ if len(m.Annotations) == 0 {
+ var21 = true
+ }
+ if var21 {
+ if err := fieldTarget20.FromZero(tt.NonOptional().Field(5).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget22, err := fieldTarget20.StartList(tt.NonOptional().Field(5).Type, len(m.Annotations))
if err != nil {
return err
}
+ for i, elem24 := range m.Annotations {
+ elemTarget23, err := listTarget22.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem18.FillVDLTarget(elemTarget17, tt.NonOptional().Field(5).Type.Elem()); err != nil {
- return err
+ if err := elem24.FillVDLTarget(elemTarget23, tt.NonOptional().Field(5).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget22.FinishElem(elemTarget23); err != nil {
+ return err
+ }
}
- if err := listTarget16.FinishElem(elemTarget17); err != nil {
+ if err := fieldTarget20.FinishList(listTarget22); err != nil {
return err
}
}
- if err := fieldTarget15.FinishList(listTarget16); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget19, fieldTarget20); err != nil {
return err
}
}
@@ -311,6 +380,10 @@
return nil
}
+func (t *SpanRecordTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = SpanRecord{}
+ return nil
+}
// []Annotation
type __VDLTarget1_list struct {
@@ -344,6 +417,10 @@
return nil
}
+func (t *__VDLTarget1_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []Annotation(nil)
+ return nil
+}
type TraceRecord struct {
Id uniqueid.Id
@@ -360,47 +437,65 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Id")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Id.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Id == uniqueid.Id{})
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Id.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Spans")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Spans")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- listTarget6, err := fieldTarget5.StartList(tt.NonOptional().Field(1).Type, len(m.Spans))
- if err != nil {
- return err
+ var var7 bool
+ if len(m.Spans) == 0 {
+ var7 = true
}
- for i, elem8 := range m.Spans {
- elemTarget7, err := listTarget6.StartElem(i)
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ listTarget8, err := fieldTarget6.StartList(tt.NonOptional().Field(1).Type, len(m.Spans))
if err != nil {
return err
}
+ for i, elem10 := range m.Spans {
+ elemTarget9, err := listTarget8.StartElem(i)
+ if err != nil {
+ return err
+ }
- if err := elem8.FillVDLTarget(elemTarget7, tt.NonOptional().Field(1).Type.Elem()); err != nil {
- return err
+ if err := elem10.FillVDLTarget(elemTarget9, tt.NonOptional().Field(1).Type.Elem()); err != nil {
+ return err
+ }
+ if err := listTarget8.FinishElem(elemTarget9); err != nil {
+ return err
+ }
}
- if err := listTarget6.FinishElem(elemTarget7); err != nil {
+ if err := fieldTarget6.FinishList(listTarget8); err != nil {
return err
}
}
- if err := fieldTarget5.FinishList(listTarget6); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -450,6 +545,10 @@
return nil
}
+func (t *TraceRecordTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = TraceRecord{}
+ return nil
+}
// []SpanRecord
type __VDLTarget2_list struct {
@@ -483,6 +582,10 @@
return nil
}
+func (t *__VDLTarget2_list) FromZero(tt *vdl.Type) error {
+ *t.Value = []SpanRecord(nil)
+ return nil
+}
type TraceFlags int32
@@ -537,6 +640,10 @@
return nil
}
+func (t *TraceFlagsTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = TraceFlags(0)
+ return nil
+}
// Request is the object that carries trace informtion between processes.
type Request struct {
@@ -556,58 +663,89 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("SpanId")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.SpanId.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.SpanId == uniqueid.Id{})
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.SpanId.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("TraceId")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("TraceId")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.TraceId.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := (m.TraceId == uniqueid.Id{})
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.TraceId.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Flags")
+ keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Flags")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Flags.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("LogLevel")
- if err != vdl.ErrFieldNoExist && err != nil {
- return err
- }
- if err != vdl.ErrFieldNoExist {
- if err := fieldTarget9.FromInt(int64(m.LogLevel), tt.NonOptional().Field(3).Type); err != nil {
- return err
+ var10 := (m.Flags == TraceFlags(0))
+ if var10 {
+ if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Flags.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
return err
}
}
+ keyTarget11, fieldTarget12, err := fieldsTarget1.StartField("LogLevel")
+ if err != vdl.ErrFieldNoExist && err != nil {
+ return err
+ }
+ if err != vdl.ErrFieldNoExist {
+
+ var13 := (m.LogLevel == int32(0))
+ if var13 {
+ if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ } else {
+ if err := fieldTarget12.FromInt(int64(m.LogLevel), tt.NonOptional().Field(3).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget11, fieldTarget12); err != nil {
+ return err
+ }
+ }
if err := t.FinishFields(fieldsTarget1); err != nil {
return err
}
@@ -664,6 +802,10 @@
return nil
}
+func (t *RequestTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Request{}
+ return nil
+}
type Response struct {
// Flags give options for trace collection, the client should alter its
@@ -684,30 +826,52 @@
if err != nil {
return err
}
-
keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Flags")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Flags.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
- return err
+ var4 := (m.Flags == TraceFlags(0))
+ if var4 {
+ if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Flags.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(0).Type); err != nil {
+ return err
+ }
}
if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
return err
}
}
- keyTarget4, fieldTarget5, err := fieldsTarget1.StartField("Trace")
+ keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Trace")
if err != vdl.ErrFieldNoExist && err != nil {
return err
}
if err != vdl.ErrFieldNoExist {
- if err := m.Trace.FillVDLTarget(fieldTarget5, tt.NonOptional().Field(1).Type); err != nil {
- return err
+ var7 := true
+ var8 := (m.Trace.Id == uniqueid.Id{})
+ var7 = var7 && var8
+ var var9 bool
+ if len(m.Trace.Spans) == 0 {
+ var9 = true
}
- if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil {
+ var7 = var7 && var9
+ if var7 {
+ if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ } else {
+
+ if err := m.Trace.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
+ return err
+ }
+ }
+ if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
return err
}
}
@@ -757,16 +921,10 @@
return nil
}
-
-// Create zero values for each type.
-var (
- __VDLZeroAnnotation = Annotation{}
- __VDLZeroSpanRecord = SpanRecord{}
- __VDLZeroTraceRecord = TraceRecord{}
- __VDLZeroTraceFlags = TraceFlags(0)
- __VDLZeroRequest = Request{}
- __VDLZeroResponse = Response{}
-)
+func (t *ResponseTarget) FromZero(tt *vdl.Type) error {
+ *t.Value = Response{}
+ return nil
+}
//////////////////////////////////////////////////
// Const definitions
@@ -793,6 +951,7 @@
if __VDLInitCalled {
return struct{}{}
}
+ __VDLInitCalled = true
// Register types.
vdl.Register((*Annotation)(nil))
