| // 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: watchable |
| |
| package watchable |
| |
| import ( |
| "fmt" |
| "reflect" |
| "v.io/v23/vdl" |
| "v.io/x/ref/services/syncbase/server/interfaces" |
| ) |
| |
| var _ = __VDLInit() // Must be first; see __VDLInit comments for details. |
| |
| ////////////////////////////////////////////////// |
| // Type definitions |
| |
| // GetOp represents a store get operation. |
| type GetOp struct { |
| Key []byte |
| } |
| |
| func (GetOp) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/syncbase/server/watchable.GetOp"` |
| }) { |
| } |
| |
| func (m *GetOp) 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 { |
| |
| if err := fieldTarget3.FromBytes([]byte(m.Key), 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 *GetOp) MakeVDLTarget() vdl.Target { |
| return &GetOpTarget{Value: m} |
| } |
| |
| type GetOpTarget struct { |
| Value *GetOp |
| keyTarget vdl.BytesTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *GetOpTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*GetOp)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *GetOpTarget) 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 |
| default: |
| return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/syncbase/server/watchable.GetOp", name) |
| } |
| } |
| func (t *GetOpTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *GetOpTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| // ScanOp represents a store scan operation. |
| type ScanOp struct { |
| Start []byte |
| Limit []byte |
| } |
| |
| func (ScanOp) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/syncbase/server/watchable.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 { |
| |
| if err := fieldTarget3.FromBytes([]byte(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") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| |
| if err := fieldTarget5.FromBytes([]byte(m.Limit), tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); 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.BytesTarget |
| limitTarget vdl.BytesTarget |
| 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/x/ref/services/syncbase/server/watchable.ScanOp", name) |
| } |
| } |
| func (t *ScanOpTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *ScanOpTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| // PutOp represents a store put operation. The new version is written instead |
| // of the value to avoid duplicating the user data in the store. The version |
| // is used to access the user data of that specific mutation. The key and the |
| // version of the permissions entry that was checked to allow this put operation |
| // are also tracked to secure the access to this history. |
| type PutOp struct { |
| Key []byte |
| Version []byte |
| PermKey []byte |
| PermVersion []byte |
| } |
| |
| func (PutOp) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/syncbase/server/watchable.PutOp"` |
| }) { |
| } |
| |
| func (m *PutOp) 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 { |
| |
| if err := fieldTarget3.FromBytes([]byte(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("Version") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| |
| if err := fieldTarget5.FromBytes([]byte(m.Version), tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil { |
| return err |
| } |
| } |
| keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("PermKey") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| |
| if err := fieldTarget7.FromBytes([]byte(m.PermKey), tt.NonOptional().Field(2).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil { |
| return err |
| } |
| } |
| keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("PermVersion") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| |
| if err := fieldTarget9.FromBytes([]byte(m.PermVersion), tt.NonOptional().Field(3).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 *PutOp) MakeVDLTarget() vdl.Target { |
| return &PutOpTarget{Value: m} |
| } |
| |
| type PutOpTarget struct { |
| Value *PutOp |
| keyTarget vdl.BytesTarget |
| versionTarget vdl.BytesTarget |
| permKeyTarget vdl.BytesTarget |
| permVersionTarget vdl.BytesTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *PutOpTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*PutOp)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *PutOpTarget) 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 "Version": |
| t.versionTarget.Value = &t.Value.Version |
| target, err := &t.versionTarget, error(nil) |
| return nil, target, err |
| case "PermKey": |
| t.permKeyTarget.Value = &t.Value.PermKey |
| target, err := &t.permKeyTarget, error(nil) |
| return nil, target, err |
| case "PermVersion": |
| t.permVersionTarget.Value = &t.Value.PermVersion |
| target, err := &t.permVersionTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/syncbase/server/watchable.PutOp", name) |
| } |
| } |
| func (t *PutOpTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *PutOpTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| // DeleteOp represents a store delete operation. The key and the version of the |
| // permissions entry that was checked to allow this delete operation are also |
| // tracked to secure the access to this history. |
| type DeleteOp struct { |
| Key []byte |
| PermKey []byte |
| PermVersion []byte |
| } |
| |
| func (DeleteOp) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/syncbase/server/watchable.DeleteOp"` |
| }) { |
| } |
| |
| func (m *DeleteOp) 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 { |
| |
| if err := fieldTarget3.FromBytes([]byte(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("PermKey") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| |
| if err := fieldTarget5.FromBytes([]byte(m.PermKey), tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil { |
| return err |
| } |
| } |
| keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("PermVersion") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| |
| if err := fieldTarget7.FromBytes([]byte(m.PermVersion), tt.NonOptional().Field(2).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil { |
| return err |
| } |
| } |
| if err := t.FinishFields(fieldsTarget1); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *DeleteOp) MakeVDLTarget() vdl.Target { |
| return &DeleteOpTarget{Value: m} |
| } |
| |
| type DeleteOpTarget struct { |
| Value *DeleteOp |
| keyTarget vdl.BytesTarget |
| permKeyTarget vdl.BytesTarget |
| permVersionTarget vdl.BytesTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *DeleteOpTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*DeleteOp)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *DeleteOpTarget) 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 "PermKey": |
| t.permKeyTarget.Value = &t.Value.PermKey |
| target, err := &t.permKeyTarget, error(nil) |
| return nil, target, err |
| case "PermVersion": |
| t.permVersionTarget.Value = &t.Value.PermVersion |
| target, err := &t.permVersionTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/syncbase/server/watchable.DeleteOp", name) |
| } |
| } |
| func (t *DeleteOpTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *DeleteOpTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| // SyncgroupOp represents a change in the set of prefixes that should be tracked |
| // by sync, i.e. the union of prefix sets across all syncgroups. Note that an |
| // individual syncgroup's prefixes cannot be changed; this record type is used |
| // to track changes due to syncgroup create/join/leave/destroy. |
| type SyncgroupOp struct { |
| SgId interfaces.GroupId |
| Prefixes []string |
| Remove bool |
| } |
| |
| func (SyncgroupOp) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/syncbase/server/watchable.SyncgroupOp"` |
| }) { |
| } |
| |
| func (m *SyncgroupOp) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("SgId") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| |
| if err := m.SgId.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("Prefixes") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| |
| listTarget6, err := fieldTarget5.StartList(tt.NonOptional().Field(1).Type, len(m.Prefixes)) |
| if err != nil { |
| return err |
| } |
| for i, elem8 := range m.Prefixes { |
| elemTarget7, err := listTarget6.StartElem(i) |
| if err != nil { |
| return err |
| } |
| if err := elemTarget7.FromString(string(elem8), tt.NonOptional().Field(1).Type.Elem()); err != nil { |
| return err |
| } |
| if err := listTarget6.FinishElem(elemTarget7); err != nil { |
| return err |
| } |
| } |
| if err := fieldTarget5.FinishList(listTarget6); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil { |
| return err |
| } |
| } |
| keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Remove") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| if err := fieldTarget10.FromBool(bool(m.Remove), 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 *SyncgroupOp) MakeVDLTarget() vdl.Target { |
| return &SyncgroupOpTarget{Value: m} |
| } |
| |
| type SyncgroupOpTarget struct { |
| Value *SyncgroupOp |
| sgIdTarget interfaces.GroupIdTarget |
| prefixesTarget vdl.StringSliceTarget |
| removeTarget vdl.BoolTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *SyncgroupOpTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*SyncgroupOp)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *SyncgroupOpTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "SgId": |
| t.sgIdTarget.Value = &t.Value.SgId |
| target, err := &t.sgIdTarget, 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 "Remove": |
| t.removeTarget.Value = &t.Value.Remove |
| target, err := &t.removeTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/syncbase/server/watchable.SyncgroupOp", name) |
| } |
| } |
| func (t *SyncgroupOpTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *SyncgroupOpTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| // SyncSnapshotOp represents a snapshot operation when creating and joining a |
| // syncgroup. The sync watcher needs to get a snapshot of the Database at the |
| // point of creating/joining a syncgroup. A SyncSnapshotOp entry is written to |
| // the log for each Database key that falls within the syncgroup prefixes. This |
| // allows sync to initialize its metadata at the correct versions of the objects |
| // when they become syncable. These log entries should be filtered by the |
| // client-facing Watch interface because the user data did not actually change. |
| // The key and the version of the permissions entry that was checked when the |
| // key was accessed are also tracked to secure the access to this history. |
| type SyncSnapshotOp struct { |
| Key []byte |
| Version []byte |
| PermKey []byte |
| PermVersion []byte |
| } |
| |
| func (SyncSnapshotOp) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/syncbase/server/watchable.SyncSnapshotOp"` |
| }) { |
| } |
| |
| func (m *SyncSnapshotOp) 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 { |
| |
| if err := fieldTarget3.FromBytes([]byte(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("Version") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| |
| if err := fieldTarget5.FromBytes([]byte(m.Version), tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget4, fieldTarget5); err != nil { |
| return err |
| } |
| } |
| keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("PermKey") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| |
| if err := fieldTarget7.FromBytes([]byte(m.PermKey), tt.NonOptional().Field(2).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil { |
| return err |
| } |
| } |
| keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("PermVersion") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| |
| if err := fieldTarget9.FromBytes([]byte(m.PermVersion), tt.NonOptional().Field(3).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 *SyncSnapshotOp) MakeVDLTarget() vdl.Target { |
| return &SyncSnapshotOpTarget{Value: m} |
| } |
| |
| type SyncSnapshotOpTarget struct { |
| Value *SyncSnapshotOp |
| keyTarget vdl.BytesTarget |
| versionTarget vdl.BytesTarget |
| permKeyTarget vdl.BytesTarget |
| permVersionTarget vdl.BytesTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *SyncSnapshotOpTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*SyncSnapshotOp)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *SyncSnapshotOpTarget) 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 "Version": |
| t.versionTarget.Value = &t.Value.Version |
| target, err := &t.versionTarget, error(nil) |
| return nil, target, err |
| case "PermKey": |
| t.permKeyTarget.Value = &t.Value.PermKey |
| target, err := &t.permKeyTarget, error(nil) |
| return nil, target, err |
| case "PermVersion": |
| t.permVersionTarget.Value = &t.Value.PermVersion |
| target, err := &t.permVersionTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/syncbase/server/watchable.SyncSnapshotOp", name) |
| } |
| } |
| func (t *SyncSnapshotOpTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *SyncSnapshotOpTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| // StateChange represents the set of types of state change requests possible. |
| type StateChange int |
| |
| const ( |
| StateChangePauseSync StateChange = iota |
| StateChangeResumeSync |
| ) |
| |
| // StateChangeAll holds all labels for StateChange. |
| var StateChangeAll = [...]StateChange{StateChangePauseSync, StateChangeResumeSync} |
| |
| // StateChangeFromString creates a StateChange from a string label. |
| func StateChangeFromString(label string) (x StateChange, err error) { |
| err = x.Set(label) |
| return |
| } |
| |
| // Set assigns label to x. |
| func (x *StateChange) Set(label string) error { |
| switch label { |
| case "PauseSync", "pausesync": |
| *x = StateChangePauseSync |
| return nil |
| case "ResumeSync", "resumesync": |
| *x = StateChangeResumeSync |
| return nil |
| } |
| *x = -1 |
| return fmt.Errorf("unknown label %q in watchable.StateChange", label) |
| } |
| |
| // String returns the string label of x. |
| func (x StateChange) String() string { |
| switch x { |
| case StateChangePauseSync: |
| return "PauseSync" |
| case StateChangeResumeSync: |
| return "ResumeSync" |
| } |
| return "" |
| } |
| |
| func (StateChange) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/syncbase/server/watchable.StateChange"` |
| Enum struct{ PauseSync, ResumeSync string } |
| }) { |
| } |
| |
| func (m *StateChange) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| if err := t.FromEnumLabel((*m).String(), tt); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (m *StateChange) MakeVDLTarget() vdl.Target { |
| return &StateChangeTarget{Value: m} |
| } |
| |
| type StateChangeTarget struct { |
| Value *StateChange |
| vdl.TargetBase |
| } |
| |
| func (t *StateChangeTarget) FromEnumLabel(src string, tt *vdl.Type) error { |
| |
| if ttWant := vdl.TypeOf((*StateChange)(nil)); !vdl.Compatible(tt, ttWant) { |
| return fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| switch src { |
| case "PauseSync": |
| *t.Value = 0 |
| case "ResumeSync": |
| *t.Value = 1 |
| default: |
| return fmt.Errorf("label %s not in enum v.io/x/ref/services/syncbase/server/watchable.StateChange", src) |
| } |
| |
| return nil |
| } |
| |
| // DbStateChangeRequestOp represents a database state change request. |
| // Specifically there are two events that create this op: |
| // PauseSync, indicating a client request to pause sync on this db. |
| // ResumeSync, indicating a client request to resume sync on this db. |
| // Client watcher will ignore this op. |
| type DbStateChangeRequestOp struct { |
| RequestType StateChange |
| } |
| |
| func (DbStateChangeRequestOp) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/syncbase/server/watchable.DbStateChangeRequestOp"` |
| }) { |
| } |
| |
| func (m *DbStateChangeRequestOp) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("RequestType") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| |
| if err := m.RequestType.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 *DbStateChangeRequestOp) MakeVDLTarget() vdl.Target { |
| return &DbStateChangeRequestOpTarget{Value: m} |
| } |
| |
| type DbStateChangeRequestOpTarget struct { |
| Value *DbStateChangeRequestOp |
| requestTypeTarget StateChangeTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *DbStateChangeRequestOpTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*DbStateChangeRequestOp)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *DbStateChangeRequestOpTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "RequestType": |
| t.requestTypeTarget.Value = &t.Value.RequestType |
| target, err := &t.requestTypeTarget, error(nil) |
| return nil, target, err |
| default: |
| return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/syncbase/server/watchable.DbStateChangeRequestOp", name) |
| } |
| } |
| func (t *DbStateChangeRequestOpTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *DbStateChangeRequestOpTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| type ( |
| // Op represents any single field of the Op union type. |
| // |
| // Op represents a store operation. |
| Op 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 Op union type. |
| __VDLReflect(__OpReflect) |
| FillVDLTarget(vdl.Target, *vdl.Type) error |
| } |
| // OpGet represents field Get of the Op union type. |
| OpGet struct{ Value GetOp } |
| // OpScan represents field Scan of the Op union type. |
| OpScan struct{ Value ScanOp } |
| // OpPut represents field Put of the Op union type. |
| OpPut struct{ Value PutOp } |
| // OpDelete represents field Delete of the Op union type. |
| OpDelete struct{ Value DeleteOp } |
| // OpSyncgroup represents field Syncgroup of the Op union type. |
| OpSyncgroup struct{ Value SyncgroupOp } |
| // OpSyncSnapshot represents field SyncSnapshot of the Op union type. |
| OpSyncSnapshot struct{ Value SyncSnapshotOp } |
| // OpDbStateChangeRequest represents field DbStateChangeRequest of the Op union type. |
| OpDbStateChangeRequest struct{ Value DbStateChangeRequestOp } |
| // __OpReflect describes the Op union type. |
| __OpReflect struct { |
| Name string `vdl:"v.io/x/ref/services/syncbase/server/watchable.Op"` |
| Type Op |
| Union struct { |
| Get OpGet |
| Scan OpScan |
| Put OpPut |
| Delete OpDelete |
| Syncgroup OpSyncgroup |
| SyncSnapshot OpSyncSnapshot |
| DbStateChangeRequest OpDbStateChangeRequest |
| } |
| } |
| ) |
| |
| func (x OpGet) Index() int { return 0 } |
| func (x OpGet) Interface() interface{} { return x.Value } |
| func (x OpGet) Name() string { return "Get" } |
| func (x OpGet) __VDLReflect(__OpReflect) {} |
| |
| func (m OpGet) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Get") |
| 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 OpGet) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x OpScan) Index() int { return 1 } |
| func (x OpScan) Interface() interface{} { return x.Value } |
| func (x OpScan) Name() string { return "Scan" } |
| func (x OpScan) __VDLReflect(__OpReflect) {} |
| |
| func (m OpScan) 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(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 OpScan) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x OpPut) Index() int { return 2 } |
| func (x OpPut) Interface() interface{} { return x.Value } |
| func (x OpPut) Name() string { return "Put" } |
| func (x OpPut) __VDLReflect(__OpReflect) {} |
| |
| func (m OpPut) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Put") |
| 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 OpPut) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x OpDelete) Index() int { return 3 } |
| func (x OpDelete) Interface() interface{} { return x.Value } |
| func (x OpDelete) Name() string { return "Delete" } |
| func (x OpDelete) __VDLReflect(__OpReflect) {} |
| |
| func (m OpDelete) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Delete") |
| if err != nil { |
| return err |
| } |
| |
| if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(3).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 OpDelete) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x OpSyncgroup) Index() int { return 4 } |
| func (x OpSyncgroup) Interface() interface{} { return x.Value } |
| func (x OpSyncgroup) Name() string { return "Syncgroup" } |
| func (x OpSyncgroup) __VDLReflect(__OpReflect) {} |
| |
| func (m OpSyncgroup) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Syncgroup") |
| if err != nil { |
| return err |
| } |
| |
| if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(4).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 OpSyncgroup) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x OpSyncSnapshot) Index() int { return 5 } |
| func (x OpSyncSnapshot) Interface() interface{} { return x.Value } |
| func (x OpSyncSnapshot) Name() string { return "SyncSnapshot" } |
| func (x OpSyncSnapshot) __VDLReflect(__OpReflect) {} |
| |
| func (m OpSyncSnapshot) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("SyncSnapshot") |
| if err != nil { |
| return err |
| } |
| |
| if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(5).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 OpSyncSnapshot) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| func (x OpDbStateChangeRequest) Index() int { return 6 } |
| func (x OpDbStateChangeRequest) Interface() interface{} { return x.Value } |
| func (x OpDbStateChangeRequest) Name() string { return "DbStateChangeRequest" } |
| func (x OpDbStateChangeRequest) __VDLReflect(__OpReflect) {} |
| |
| func (m OpDbStateChangeRequest) FillVDLTarget(t vdl.Target, tt *vdl.Type) error { |
| fieldsTarget1, err := t.StartFields(tt) |
| if err != nil { |
| return err |
| } |
| keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("DbStateChangeRequest") |
| if err != nil { |
| return err |
| } |
| |
| if err := m.Value.FillVDLTarget(fieldTarget3, tt.NonOptional().Field(6).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 OpDbStateChangeRequest) MakeVDLTarget() vdl.Target { |
| return nil |
| } |
| |
| // LogEntry represents a single store operation. This operation may have been |
| // part of a transaction, as signified by the Continued boolean. Read-only |
| // operations (and read-only transactions) are not logged. |
| type LogEntry struct { |
| // The store operation that was performed. |
| Op Op |
| // Time when the operation was committed in nanoseconds since the epoch. |
| // Note: We don't use time.Time here because VDL's time.Time consists of |
| // {Seconds int64, Nanos int32}, which is more expensive than a single int64. |
| CommitTimestamp int64 |
| // Operation came from sync (used for echo suppression). |
| FromSync bool |
| // If true, this entry is followed by more entries that belong to the same |
| // commit as this entry. |
| Continued bool |
| } |
| |
| func (LogEntry) __VDLReflect(struct { |
| Name string `vdl:"v.io/x/ref/services/syncbase/server/watchable.LogEntry"` |
| }) { |
| } |
| |
| func (m *LogEntry) 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 { |
| |
| unionValue4 := m.Op |
| if unionValue4 == nil { |
| unionValue4 = OpGet{} |
| } |
| if err := unionValue4.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("CommitTimestamp") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| if err := fieldTarget6.FromInt(int64(m.CommitTimestamp), tt.NonOptional().Field(1).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil { |
| return err |
| } |
| } |
| keyTarget7, fieldTarget8, err := fieldsTarget1.StartField("FromSync") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| if err := fieldTarget8.FromBool(bool(m.FromSync), tt.NonOptional().Field(2).Type); err != nil { |
| return err |
| } |
| if err := fieldsTarget1.FinishField(keyTarget7, fieldTarget8); err != nil { |
| return err |
| } |
| } |
| keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Continued") |
| if err != vdl.ErrFieldNoExist && err != nil { |
| return err |
| } |
| if err != vdl.ErrFieldNoExist { |
| if err := fieldTarget10.FromBool(bool(m.Continued), tt.NonOptional().Field(3).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 *LogEntry) MakeVDLTarget() vdl.Target { |
| return &LogEntryTarget{Value: m} |
| } |
| |
| type LogEntryTarget struct { |
| Value *LogEntry |
| |
| commitTimestampTarget vdl.Int64Target |
| fromSyncTarget vdl.BoolTarget |
| continuedTarget vdl.BoolTarget |
| vdl.TargetBase |
| vdl.FieldsTargetBase |
| } |
| |
| func (t *LogEntryTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) { |
| |
| if ttWant := vdl.TypeOf((*LogEntry)(nil)).Elem(); !vdl.Compatible(tt, ttWant) { |
| return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant) |
| } |
| return t, nil |
| } |
| func (t *LogEntryTarget) StartField(name string) (key, field vdl.Target, _ error) { |
| switch name { |
| case "Op": |
| target, err := vdl.ReflectTarget(reflect.ValueOf(&t.Value.Op)) |
| return nil, target, err |
| case "CommitTimestamp": |
| t.commitTimestampTarget.Value = &t.Value.CommitTimestamp |
| target, err := &t.commitTimestampTarget, error(nil) |
| return nil, target, err |
| case "FromSync": |
| t.fromSyncTarget.Value = &t.Value.FromSync |
| target, err := &t.fromSyncTarget, 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/x/ref/services/syncbase/server/watchable.LogEntry", name) |
| } |
| } |
| func (t *LogEntryTarget) FinishField(_, _ vdl.Target) error { |
| return nil |
| } |
| func (t *LogEntryTarget) FinishFields(_ vdl.FieldsTarget) error { |
| |
| return nil |
| } |
| |
| // Create zero values for each type. |
| var ( |
| __VDLZeroGetOp = GetOp{} |
| __VDLZeroScanOp = ScanOp{} |
| __VDLZeroPutOp = PutOp{} |
| __VDLZeroDeleteOp = DeleteOp{} |
| __VDLZeroSyncgroupOp = SyncgroupOp{} |
| __VDLZeroSyncSnapshotOp = SyncSnapshotOp{} |
| __VDLZeroStateChange = StateChangePauseSync |
| __VDLZeroDbStateChangeRequestOp = DbStateChangeRequestOp{} |
| __VDLZeroOp = Op(OpGet{}) |
| __VDLZeroLogEntry = LogEntry{ |
| Op: OpGet{}, |
| } |
| ) |
| |
| 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{}{} |
| } |
| |
| // Register types. |
| vdl.Register((*GetOp)(nil)) |
| vdl.Register((*ScanOp)(nil)) |
| vdl.Register((*PutOp)(nil)) |
| vdl.Register((*DeleteOp)(nil)) |
| vdl.Register((*SyncgroupOp)(nil)) |
| vdl.Register((*SyncSnapshotOp)(nil)) |
| vdl.Register((*StateChange)(nil)) |
| vdl.Register((*DbStateChangeRequestOp)(nil)) |
| vdl.Register((*Op)(nil)) |
| vdl.Register((*LogEntry)(nil)) |
| |
| return struct{}{} |
| } |
