services/syncbase/server/server.vdl.go

// 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: server

package server

import (
	"fmt"
	"v.io/v23/security/access"
	"v.io/v23/services/syncbase"
	"v.io/v23/vdl"
)

var _ = __VDLInit() // Must be first; see __VDLInit comments for details.

//////////////////////////////////////////////////
// Type definitions

// ServiceData represents the persistent state of a Service.
type ServiceData struct {
	Version uint64 // covers the fields below
	Perms   access.Permissions
}

func (ServiceData) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/services/syncbase/server.ServiceData"`
}) {
}

func (m *ServiceData) 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 == uint64(0))
		if var4 {
			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
		} else {
			if err := fieldTarget3.FromUint(uint64(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("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 *ServiceData) MakeVDLTarget() vdl.Target {
	return &ServiceDataTarget{Value: m}
}

type ServiceDataTarget struct {
	Value         *ServiceData
	versionTarget vdl.Uint64Target
	permsTarget   access.PermissionsTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *ServiceDataTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*ServiceData)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *ServiceDataTarget) 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 "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/x/ref/services/syncbase/server.ServiceData", name)
	}
}
func (t *ServiceDataTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *ServiceDataTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *ServiceDataTarget) FromZero(tt *vdl.Type) error {
	*t.Value = ServiceData{}
	return nil
}

// AppData represents the persistent state of an App.
type AppData struct {
	Name    string
	Version uint64 // covers the fields below
	Perms   access.Permissions
}

func (AppData) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/services/syncbase/server.AppData"`
}) {
}

func (m *AppData) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		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
		}
	}
	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Version")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		var7 := (m.Version == uint64(0))
		if var7 {
			if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		} else {
			if err := fieldTarget6.FromUint(uint64(m.Version), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
			return err
		}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Perms")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		var var10 bool
		if len(m.Perms) == 0 {
			var10 = true
		}
		if var10 {
			if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
		} else {

			if err := m.Perms.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 *AppData) MakeVDLTarget() vdl.Target {
	return &AppDataTarget{Value: m}
}

type AppDataTarget struct {
	Value         *AppData
	nameTarget    vdl.StringTarget
	versionTarget vdl.Uint64Target
	permsTarget   access.PermissionsTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *AppDataTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*AppData)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *AppDataTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		t.nameTarget.Value = &t.Value.Name
		target, err := &t.nameTarget, 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 "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/x/ref/services/syncbase/server.AppData", name)
	}
}
func (t *AppDataTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *AppDataTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *AppDataTarget) FromZero(tt *vdl.Type) error {
	*t.Value = AppData{}
	return nil
}

// DbInfo contains information about one database for an App.
type DbInfo struct {
	Name string
	// Select fields from DatabaseOptions, needed in order to open storage engine
	// on restart.
	RootDir string // interpreted by storage engine
	Engine  string // name of storage engine, e.g. "leveldb"
}

func (DbInfo) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/services/syncbase/server.DbInfo"`
}) {
}

func (m *DbInfo) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		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
		}
	}
	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("RootDir")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		var7 := (m.RootDir == "")
		if var7 {
			if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		} else {
			if err := fieldTarget6.FromString(string(m.RootDir), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
			return err
		}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Engine")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		var10 := (m.Engine == "")
		if var10 {
			if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
		} else {
			if err := fieldTarget9.FromString(string(m.Engine), 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 *DbInfo) MakeVDLTarget() vdl.Target {
	return &DbInfoTarget{Value: m}
}

type DbInfoTarget struct {
	Value         *DbInfo
	nameTarget    vdl.StringTarget
	rootDirTarget vdl.StringTarget
	engineTarget  vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *DbInfoTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*DbInfo)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *DbInfoTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		t.nameTarget.Value = &t.Value.Name
		target, err := &t.nameTarget, error(nil)
		return nil, target, err
	case "RootDir":
		t.rootDirTarget.Value = &t.Value.RootDir
		target, err := &t.rootDirTarget, error(nil)
		return nil, target, err
	case "Engine":
		t.engineTarget.Value = &t.Value.Engine
		target, err := &t.engineTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/syncbase/server.DbInfo", name)
	}
}
func (t *DbInfoTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *DbInfoTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *DbInfoTarget) FromZero(tt *vdl.Type) error {
	*t.Value = DbInfo{}
	return nil
}

// DatabaseData represents the persistent state of a Database.
type DatabaseData struct {
	Name           string
	Version        uint64 // covers the Perms field below
	Perms          access.Permissions
	SchemaMetadata *syncbase.SchemaMetadata
}

func (DatabaseData) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/services/syncbase/server.DatabaseData"`
}) {
}

func (m *DatabaseData) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		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
		}
	}
	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Version")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		var7 := (m.Version == uint64(0))
		if var7 {
			if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		} else {
			if err := fieldTarget6.FromUint(uint64(m.Version), tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
			return err
		}
	}
	keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Perms")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		var var10 bool
		if len(m.Perms) == 0 {
			var10 = true
		}
		if var10 {
			if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
		} else {

			if err := m.Perms.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("SchemaMetadata")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		var13 := (m.SchemaMetadata == (*syncbase.SchemaMetadata)(nil))
		if var13 {
			if err := fieldTarget12.FromZero(tt.NonOptional().Field(3).Type); err != nil {
				return err
			}
		} else {

			if err := m.SchemaMetadata.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 *DatabaseData) MakeVDLTarget() vdl.Target {
	return &DatabaseDataTarget{Value: m}
}

type DatabaseDataTarget struct {
	Value                *DatabaseData
	nameTarget           vdl.StringTarget
	versionTarget        vdl.Uint64Target
	permsTarget          access.PermissionsTarget
	schemaMetadataTarget __VDLTarget1_optional
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *DatabaseDataTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*DatabaseData)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *DatabaseDataTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		t.nameTarget.Value = &t.Value.Name
		target, err := &t.nameTarget, 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 "Perms":
		t.permsTarget.Value = &t.Value.Perms
		target, err := &t.permsTarget, error(nil)
		return nil, target, err
	case "SchemaMetadata":
		t.schemaMetadataTarget.Value = &t.Value.SchemaMetadata
		target, err := &t.schemaMetadataTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/services/syncbase/server.DatabaseData", name)
	}
}
func (t *DatabaseDataTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *DatabaseDataTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *DatabaseDataTarget) FromZero(tt *vdl.Type) error {
	*t.Value = DatabaseData{}
	return nil
}

// Optional syncbase.SchemaMetadata
type __VDLTarget1_optional struct {
	Value      **syncbase.SchemaMetadata
	elemTarget syncbase.SchemaMetadataTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *__VDLTarget1_optional) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if *t.Value == nil {
		*t.Value = &syncbase.SchemaMetadata{}
	}
	t.elemTarget.Value = *t.Value
	target, err := &t.elemTarget, error(nil)
	if err != nil {
		return nil, err
	}
	return target.StartFields(tt)
}
func (t *__VDLTarget1_optional) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *__VDLTarget1_optional) FromZero(tt *vdl.Type) error {
	*t.Value = (*syncbase.SchemaMetadata)(nil)
	return nil
}

// CollectionData represents the persistent state of a Collection.
type CollectionData struct {
	Name  string
	Perms access.Permissions
}

func (CollectionData) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/services/syncbase/server.CollectionData"`
}) {
}

func (m *CollectionData) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Name")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		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
		}
	}
	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 *CollectionData) MakeVDLTarget() vdl.Target {
	return &CollectionDataTarget{Value: m}
}

type CollectionDataTarget struct {
	Value       *CollectionData
	nameTarget  vdl.StringTarget
	permsTarget access.PermissionsTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *CollectionDataTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {

	if ttWant := vdl.TypeOf((*CollectionData)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *CollectionDataTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Name":
		t.nameTarget.Value = &t.Value.Name
		target, err := &t.nameTarget, 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/x/ref/services/syncbase/server.CollectionData", name)
	}
}
func (t *CollectionDataTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *CollectionDataTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *CollectionDataTarget) FromZero(tt *vdl.Type) error {
	*t.Value = CollectionData{}
	return nil
}

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((*ServiceData)(nil))
	vdl.Register((*AppData)(nil))
	vdl.Register((*DbInfo)(nil))
	vdl.Register((*DatabaseData)(nil))
	vdl.Register((*CollectionData)(nil))

	return struct{}{}
}