examples/rps/rps.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: rps

// Package rps defines interfaces for playing the game Rock-Paper-Scissors.  It
// is an example of a simple Vanadium service.
//
// http://en.wikipedia.org/wiki/Rock-paper-scissors
//
// There are three different roles in the game:
//
// 1. Judge: A judge enforces the rules of the game and decides who the winner
// is. At the end of the game, the judge reports the final score to all the
// score keepers.
//
// 2. Player: A player can ask a judge to start a new game, it can challenge
// another player, and it can play a game.
//
// 3. ScoreKeeper: A score keeper receives the final score for a game after it
// ended.
package rps

import (
	"fmt"
	"io"
	"time"
	"v.io/v23"
	"v.io/v23/context"
	"v.io/v23/rpc"
	"v.io/v23/security/access"
	"v.io/v23/vdl"
	"v.io/v23/vdl/vdlconv"
	time_2 "v.io/v23/vdlroot/time"
)

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

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

// A GameId is used to uniquely identify a game within one Judge.
type GameId struct {
	Id string
}

func (GameId) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/examples/rps.GameId"`
}) {
}

func (m *GameId) 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 == "")
		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
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *GameId) MakeVDLTarget() vdl.Target {
	return &GameIdTarget{Value: m}
}

type GameIdTarget struct {
	Value    *GameId
	idTarget vdl.StringTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	if ttWant := vdl.TypeOf((*GameId)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *GameIdTarget) 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
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/examples/rps.GameId", name)
	}
}
func (t *GameIdTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *GameIdTarget) FinishFields(_ vdl.FieldsTarget) error {

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

type GameTypeTag byte

func (GameTypeTag) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/examples/rps.GameTypeTag"`
}) {
}

func (m *GameTypeTag) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromUint(uint64((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *GameTypeTag) MakeVDLTarget() vdl.Target {
	return &GameTypeTagTarget{Value: m}
}

type GameTypeTagTarget struct {
	Value *GameTypeTag
	vdl.TargetBase
}

func (t *GameTypeTagTarget) FromUint(src uint64, tt *vdl.Type) error {

	val, err := vdlconv.Uint64ToUint8(src)
	if err != nil {
		return err
	}
	*t.Value = GameTypeTag(val)

	return nil
}
func (t *GameTypeTagTarget) FromInt(src int64, tt *vdl.Type) error {

	val, err := vdlconv.Int64ToUint8(src)
	if err != nil {
		return err
	}
	*t.Value = GameTypeTag(val)

	return nil
}
func (t *GameTypeTagTarget) FromFloat(src float64, tt *vdl.Type) error {

	val, err := vdlconv.Float64ToUint8(src)
	if err != nil {
		return err
	}
	*t.Value = GameTypeTag(val)

	return nil
}
func (t *GameTypeTagTarget) FromZero(tt *vdl.Type) error {
	*t.Value = GameTypeTag(0)
	return nil
}

// GameOptions specifies the parameters of a game.
type GameOptions struct {
	NumRounds int32       // The number of rounds that a player must win to win the game.
	GameType  GameTypeTag // The type of game to play: Classic or LizardSpock.
}

func (GameOptions) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/examples/rps.GameOptions"`
}) {
}

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

		var4 := (m.NumRounds == int32(0))
		if var4 {
			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
		} else {
			if err := fieldTarget3.FromInt(int64(m.NumRounds), tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
			return err
		}
	}
	keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("GameType")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		var7 := (m.GameType == GameTypeTag(0))
		if var7 {
			if err := fieldTarget6.FromZero(tt.NonOptional().Field(1).Type); err != nil {
				return err
			}
		} else {

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

type GameOptionsTarget struct {
	Value           *GameOptions
	numRoundsTarget vdl.Int32Target
	gameTypeTarget  GameTypeTagTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	if ttWant := vdl.TypeOf((*GameOptions)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *GameOptionsTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "NumRounds":
		t.numRoundsTarget.Value = &t.Value.NumRounds
		target, err := &t.numRoundsTarget, error(nil)
		return nil, target, err
	case "GameType":
		t.gameTypeTarget.Value = &t.Value.GameType
		target, err := &t.gameTypeTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/examples/rps.GameOptions", name)
	}
}
func (t *GameOptionsTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *GameOptionsTarget) FinishFields(_ vdl.FieldsTarget) error {

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

type unused struct {
}

func (unused) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/examples/rps.unused"`
}) {
}

func (m *unused) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *unused) MakeVDLTarget() vdl.Target {
	return &unusedTarget{Value: m}
}

type unusedTarget struct {
	Value *unused
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	if ttWant := vdl.TypeOf((*unused)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *unusedTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/examples/rps.unused", name)
	}
}
func (t *unusedTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *unusedTarget) FinishFields(_ vdl.FieldsTarget) error {

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

type (
	// PlayerAction represents any single field of the PlayerAction union type.
	PlayerAction 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 PlayerAction union type.
		__VDLReflect(__PlayerActionReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
	}
	// PlayerActionMove represents field Move of the PlayerAction union type.
	PlayerActionMove struct{ Value string } // The move that the player wants to make.
	// PlayerActionQuit represents field Quit of the PlayerAction union type.
	PlayerActionQuit struct{ Value unused } // Indicates that the player is quitting the game.
	// __PlayerActionReflect describes the PlayerAction union type.
	__PlayerActionReflect struct {
		Name               string `vdl:"v.io/x/ref/examples/rps.PlayerAction"`
		Type               PlayerAction
		UnionTargetFactory playerActionTargetFactory
		Union              struct {
			Move PlayerActionMove
			Quit PlayerActionQuit
		}
	}
)

func (x PlayerActionMove) Index() int                         { return 0 }
func (x PlayerActionMove) Interface() interface{}             { return x.Value }
func (x PlayerActionMove) Name() string                       { return "Move" }
func (x PlayerActionMove) __VDLReflect(__PlayerActionReflect) {}

func (m PlayerActionMove) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Move")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromString(string(m.Value), tt.NonOptional().Field(0).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m PlayerActionMove) MakeVDLTarget() vdl.Target {
	return nil
}

func (x PlayerActionQuit) Index() int                         { return 1 }
func (x PlayerActionQuit) Interface() interface{}             { return x.Value }
func (x PlayerActionQuit) Name() string                       { return "Quit" }
func (x PlayerActionQuit) __VDLReflect(__PlayerActionReflect) {}

func (m PlayerActionQuit) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Quit")
	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 PlayerActionQuit) MakeVDLTarget() vdl.Target {
	return nil
}

type PlayerActionTarget struct {
	Value     *PlayerAction
	fieldName string

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *PlayerActionTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if ttWant := vdl.TypeOf((*PlayerAction)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}

	return t, nil
}
func (t *PlayerActionTarget) StartField(name string) (key, field vdl.Target, _ error) {
	t.fieldName = name
	switch name {
	case "Move":
		val := ""
		return nil, &vdl.StringTarget{Value: &val}, nil
	case "Quit":
		val := unused{}
		return nil, &unusedTarget{Value: &val}, nil
	default:
		return nil, nil, fmt.Errorf("field %s not in union v.io/x/ref/examples/rps.PlayerAction", name)
	}
}
func (t *PlayerActionTarget) FinishField(_, fieldTarget vdl.Target) error {
	switch t.fieldName {
	case "Move":
		*t.Value = PlayerActionMove{*(fieldTarget.(*vdl.StringTarget)).Value}
	case "Quit":
		*t.Value = PlayerActionQuit{*(fieldTarget.(*unusedTarget)).Value}
	}
	return nil
}
func (t *PlayerActionTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *PlayerActionTarget) FromZero(tt *vdl.Type) error {
	*t.Value = PlayerAction(PlayerActionMove{})
	return nil
}

type playerActionTargetFactory struct{}

func (t playerActionTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
	if typedUnion, ok := union.(*PlayerAction); ok {
		return &PlayerActionTarget{Value: typedUnion}, nil
	}
	return nil, fmt.Errorf("got %T, want *PlayerAction", union)
}

type PlayersMoves [2]string

func (PlayersMoves) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/examples/rps.PlayersMoves"`
}) {
}

func (m *PlayersMoves) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	listTarget1, err := t.StartList(tt, 2)
	if err != nil {
		return err
	}
	for i, elem3 := range *m {
		elemTarget2, err := listTarget1.StartElem(i)
		if err != nil {
			return err
		}
		if err := elemTarget2.FromString(string(elem3), tt.NonOptional().Elem()); err != nil {
			return err
		}
		if err := listTarget1.FinishElem(elemTarget2); err != nil {
			return err
		}
	}
	if err := t.FinishList(listTarget1); err != nil {
		return err
	}
	return nil
}

func (m *PlayersMoves) MakeVDLTarget() vdl.Target {
	return &PlayersMovesTarget{Value: m}
}

// PlayersMoves
type PlayersMovesTarget struct {
	Value      *PlayersMoves
	elemTarget vdl.StringTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *PlayersMovesTarget) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*PlayersMoves)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *PlayersMovesTarget) StartElem(index int) (elem vdl.Target, _ error) {
	t.elemTarget.Value = &(*t.Value)[index]
	target, err := &t.elemTarget, error(nil)
	return target, err
}
func (t *PlayersMovesTarget) FinishElem(elem vdl.Target) error {
	return nil
}
func (t *PlayersMovesTarget) FinishList(elem vdl.ListTarget) error {

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

// WinnerTag is a type used to indicate whether a round or a game was a draw,
// was won by player 1 or was won by player 2.
type WinnerTag byte

func (WinnerTag) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/examples/rps.WinnerTag"`
}) {
}

func (m *WinnerTag) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	if err := t.FromUint(uint64((*m)), tt); err != nil {
		return err
	}
	return nil
}

func (m *WinnerTag) MakeVDLTarget() vdl.Target {
	return &WinnerTagTarget{Value: m}
}

type WinnerTagTarget struct {
	Value *WinnerTag
	vdl.TargetBase
}

func (t *WinnerTagTarget) FromUint(src uint64, tt *vdl.Type) error {

	val, err := vdlconv.Uint64ToUint8(src)
	if err != nil {
		return err
	}
	*t.Value = WinnerTag(val)

	return nil
}
func (t *WinnerTagTarget) FromInt(src int64, tt *vdl.Type) error {

	val, err := vdlconv.Int64ToUint8(src)
	if err != nil {
		return err
	}
	*t.Value = WinnerTag(val)

	return nil
}
func (t *WinnerTagTarget) FromFloat(src float64, tt *vdl.Type) error {

	val, err := vdlconv.Float64ToUint8(src)
	if err != nil {
		return err
	}
	*t.Value = WinnerTag(val)

	return nil
}
func (t *WinnerTagTarget) FromZero(tt *vdl.Type) error {
	*t.Value = WinnerTag(0)
	return nil
}

// Round represents the state of a round.
type Round struct {
	Moves     PlayersMoves // Each player's move.
	Comment   string       // A text comment from judge about the round.
	Winner    WinnerTag    // Who won the round.
	StartTime time.Time    // The time at which the round started.
	EndTime   time.Time    // The time at which the round ended.
}

func (Round) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/examples/rps.Round"`
}) {
}

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

		var4 := (m.Moves == PlayersMoves{})
		if var4 {
			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
		} else {

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

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

		var10 := (m.Winner == WinnerTag(0))
		if var10 {
			if err := fieldTarget9.FromZero(tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
		} else {

			if err := m.Winner.FillVDLTarget(fieldTarget9, tt.NonOptional().Field(2).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
			return err
		}
	}
	var wireValue11 time_2.Time
	if err := time_2.TimeFromNative(&wireValue11, m.StartTime); err != nil {
		return err
	}

	keyTarget12, fieldTarget13, err := fieldsTarget1.StartField("StartTime")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		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
		}
	}
	var wireValue15 time_2.Time
	if err := time_2.TimeFromNative(&wireValue15, m.EndTime); err != nil {
		return err
	}

	keyTarget16, fieldTarget17, err := fieldsTarget1.StartField("EndTime")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		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
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *Round) MakeVDLTarget() vdl.Target {
	return &RoundTarget{Value: m}
}

type RoundTarget struct {
	Value           *Round
	movesTarget     PlayersMovesTarget
	commentTarget   vdl.StringTarget
	winnerTarget    WinnerTagTarget
	startTimeTarget time_2.TimeTarget
	endTimeTarget   time_2.TimeTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	if ttWant := vdl.TypeOf((*Round)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *RoundTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Moves":
		t.movesTarget.Value = &t.Value.Moves
		target, err := &t.movesTarget, error(nil)
		return nil, target, err
	case "Comment":
		t.commentTarget.Value = &t.Value.Comment
		target, err := &t.commentTarget, error(nil)
		return nil, target, err
	case "Winner":
		t.winnerTarget.Value = &t.Value.Winner
		target, err := &t.winnerTarget, error(nil)
		return nil, target, err
	case "StartTime":
		t.startTimeTarget.Value = &t.Value.StartTime
		target, err := &t.startTimeTarget, error(nil)
		return nil, target, err
	case "EndTime":
		t.endTimeTarget.Value = &t.Value.EndTime
		target, err := &t.endTimeTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/examples/rps.Round", name)
	}
}
func (t *RoundTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *RoundTarget) FinishFields(_ vdl.FieldsTarget) error {

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

type ScoreCard struct {
	Opts      GameOptions // The game options.
	Judge     string      // The name of the judge.
	Players   []string    // The name of the players.
	Rounds    []Round     // The outcome of each round.
	StartTime time.Time   // The time at which the game started.
	EndTime   time.Time   // The time at which the game ended.
	Winner    WinnerTag   // Who won the game.
}

func (ScoreCard) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/examples/rps.ScoreCard"`
}) {
}

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

		var4 := (m.Opts == GameOptions{})
		if var4 {
			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
		} else {

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

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

		var var10 bool
		if len(m.Players) == 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.Players))
			if err != nil {
				return err
			}
			for i, elem13 := range m.Players {
				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 := fieldTarget9.FinishList(listTarget11); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
			return err
		}
	}
	keyTarget14, fieldTarget15, err := fieldsTarget1.StartField("Rounds")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		var var16 bool
		if len(m.Rounds) == 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.Rounds))
			if err != nil {
				return err
			}
			for i, elem19 := range m.Rounds {
				elemTarget18, err := listTarget17.StartElem(i)
				if err != nil {
					return err
				}

				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 := fieldTarget15.FinishList(listTarget17); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget14, fieldTarget15); err != nil {
			return err
		}
	}
	var wireValue20 time_2.Time
	if err := time_2.TimeFromNative(&wireValue20, m.StartTime); err != nil {
		return err
	}

	keyTarget21, fieldTarget22, err := fieldsTarget1.StartField("StartTime")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		var23 := (wireValue20 == time_2.Time{})
		if var23 {
			if err := fieldTarget22.FromZero(tt.NonOptional().Field(4).Type); err != nil {
				return err
			}
		} else {

			if err := wireValue20.FillVDLTarget(fieldTarget22, tt.NonOptional().Field(4).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget21, fieldTarget22); err != nil {
			return err
		}
	}
	var wireValue24 time_2.Time
	if err := time_2.TimeFromNative(&wireValue24, m.EndTime); err != nil {
		return err
	}

	keyTarget25, fieldTarget26, err := fieldsTarget1.StartField("EndTime")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		var27 := (wireValue24 == time_2.Time{})
		if var27 {
			if err := fieldTarget26.FromZero(tt.NonOptional().Field(5).Type); err != nil {
				return err
			}
		} else {

			if err := wireValue24.FillVDLTarget(fieldTarget26, tt.NonOptional().Field(5).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget25, fieldTarget26); err != nil {
			return err
		}
	}
	keyTarget28, fieldTarget29, err := fieldsTarget1.StartField("Winner")
	if err != vdl.ErrFieldNoExist && err != nil {
		return err
	}
	if err != vdl.ErrFieldNoExist {

		var30 := (m.Winner == WinnerTag(0))
		if var30 {
			if err := fieldTarget29.FromZero(tt.NonOptional().Field(6).Type); err != nil {
				return err
			}
		} else {

			if err := m.Winner.FillVDLTarget(fieldTarget29, tt.NonOptional().Field(6).Type); err != nil {
				return err
			}
		}
		if err := fieldsTarget1.FinishField(keyTarget28, fieldTarget29); err != nil {
			return err
		}
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}
	return nil
}

func (m *ScoreCard) MakeVDLTarget() vdl.Target {
	return &ScoreCardTarget{Value: m}
}

type ScoreCardTarget struct {
	Value           *ScoreCard
	optsTarget      GameOptionsTarget
	judgeTarget     vdl.StringTarget
	playersTarget   vdl.StringSliceTarget
	roundsTarget    __VDLTarget1_list
	startTimeTarget time_2.TimeTarget
	endTimeTarget   time_2.TimeTarget
	winnerTarget    WinnerTagTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	if ttWant := vdl.TypeOf((*ScoreCard)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *ScoreCardTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "Opts":
		t.optsTarget.Value = &t.Value.Opts
		target, err := &t.optsTarget, error(nil)
		return nil, target, err
	case "Judge":
		t.judgeTarget.Value = &t.Value.Judge
		target, err := &t.judgeTarget, error(nil)
		return nil, target, err
	case "Players":
		t.playersTarget.Value = &t.Value.Players
		target, err := &t.playersTarget, error(nil)
		return nil, target, err
	case "Rounds":
		t.roundsTarget.Value = &t.Value.Rounds
		target, err := &t.roundsTarget, error(nil)
		return nil, target, err
	case "StartTime":
		t.startTimeTarget.Value = &t.Value.StartTime
		target, err := &t.startTimeTarget, error(nil)
		return nil, target, err
	case "EndTime":
		t.endTimeTarget.Value = &t.Value.EndTime
		target, err := &t.endTimeTarget, error(nil)
		return nil, target, err
	case "Winner":
		t.winnerTarget.Value = &t.Value.Winner
		target, err := &t.winnerTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/examples/rps.ScoreCard", name)
	}
}
func (t *ScoreCardTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *ScoreCardTarget) FinishFields(_ vdl.FieldsTarget) error {

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

// []Round
type __VDLTarget1_list struct {
	Value      *[]Round
	elemTarget RoundTarget
	vdl.TargetBase
	vdl.ListTargetBase
}

func (t *__VDLTarget1_list) StartList(tt *vdl.Type, len int) (vdl.ListTarget, error) {

	if ttWant := vdl.TypeOf((*[]Round)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	if cap(*t.Value) < len {
		*t.Value = make([]Round, 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 = []Round(nil)
	return nil
}

type (
	// JudgeAction represents any single field of the JudgeAction union type.
	JudgeAction 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 JudgeAction union type.
		__VDLReflect(__JudgeActionReflect)
		FillVDLTarget(vdl.Target, *vdl.Type) error
	}
	// JudgeActionPlayerNum represents field PlayerNum of the JudgeAction union type.
	JudgeActionPlayerNum struct{ Value int32 } // The player's number.
	// JudgeActionOpponentName represents field OpponentName of the JudgeAction union type.
	JudgeActionOpponentName struct{ Value string } // The name of the opponent.
	// JudgeActionMoveOptions represents field MoveOptions of the JudgeAction union type.
	JudgeActionMoveOptions struct{ Value []string } // A list of allowed moves that the player must choose from.
	// JudgeActionRoundResult represents field RoundResult of the JudgeAction union type.
	JudgeActionRoundResult struct{ Value Round } // The result of the previous round.
	// JudgeActionScore represents field Score of the JudgeAction union type.
	JudgeActionScore struct{ Value ScoreCard } // The result of the game.
	// __JudgeActionReflect describes the JudgeAction union type.
	__JudgeActionReflect struct {
		Name               string `vdl:"v.io/x/ref/examples/rps.JudgeAction"`
		Type               JudgeAction
		UnionTargetFactory judgeActionTargetFactory
		Union              struct {
			PlayerNum    JudgeActionPlayerNum
			OpponentName JudgeActionOpponentName
			MoveOptions  JudgeActionMoveOptions
			RoundResult  JudgeActionRoundResult
			Score        JudgeActionScore
		}
	}
)

func (x JudgeActionPlayerNum) Index() int                        { return 0 }
func (x JudgeActionPlayerNum) Interface() interface{}            { return x.Value }
func (x JudgeActionPlayerNum) Name() string                      { return "PlayerNum" }
func (x JudgeActionPlayerNum) __VDLReflect(__JudgeActionReflect) {}

func (m JudgeActionPlayerNum) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("PlayerNum")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromInt(int64(m.Value), tt.NonOptional().Field(0).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m JudgeActionPlayerNum) MakeVDLTarget() vdl.Target {
	return nil
}

func (x JudgeActionOpponentName) Index() int                        { return 1 }
func (x JudgeActionOpponentName) Interface() interface{}            { return x.Value }
func (x JudgeActionOpponentName) Name() string                      { return "OpponentName" }
func (x JudgeActionOpponentName) __VDLReflect(__JudgeActionReflect) {}

func (m JudgeActionOpponentName) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("OpponentName")
	if err != nil {
		return err
	}
	if err := fieldTarget3.FromString(string(m.Value), tt.NonOptional().Field(1).Type); err != nil {
		return err
	}
	if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
		return err
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m JudgeActionOpponentName) MakeVDLTarget() vdl.Target {
	return nil
}

func (x JudgeActionMoveOptions) Index() int                        { return 2 }
func (x JudgeActionMoveOptions) Interface() interface{}            { return x.Value }
func (x JudgeActionMoveOptions) Name() string                      { return "MoveOptions" }
func (x JudgeActionMoveOptions) __VDLReflect(__JudgeActionReflect) {}

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

	listTarget4, err := fieldTarget3.StartList(tt.NonOptional().Field(2).Type, len(m.Value))
	if err != nil {
		return err
	}
	for i, elem6 := range m.Value {
		elemTarget5, err := listTarget4.StartElem(i)
		if err != nil {
			return err
		}
		if err := elemTarget5.FromString(string(elem6), tt.NonOptional().Field(2).Type.Elem()); 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
	}
	if err := t.FinishFields(fieldsTarget1); err != nil {
		return err
	}

	return nil
}

func (m JudgeActionMoveOptions) MakeVDLTarget() vdl.Target {
	return nil
}

func (x JudgeActionRoundResult) Index() int                        { return 3 }
func (x JudgeActionRoundResult) Interface() interface{}            { return x.Value }
func (x JudgeActionRoundResult) Name() string                      { return "RoundResult" }
func (x JudgeActionRoundResult) __VDLReflect(__JudgeActionReflect) {}

func (m JudgeActionRoundResult) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("RoundResult")
	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 JudgeActionRoundResult) MakeVDLTarget() vdl.Target {
	return nil
}

func (x JudgeActionScore) Index() int                        { return 4 }
func (x JudgeActionScore) Interface() interface{}            { return x.Value }
func (x JudgeActionScore) Name() string                      { return "Score" }
func (x JudgeActionScore) __VDLReflect(__JudgeActionReflect) {}

func (m JudgeActionScore) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
	fieldsTarget1, err := t.StartFields(tt)
	if err != nil {
		return err
	}
	keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Score")
	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 JudgeActionScore) MakeVDLTarget() vdl.Target {
	return nil
}

type JudgeActionTarget struct {
	Value     *JudgeAction
	fieldName string

	vdl.TargetBase
	vdl.FieldsTargetBase
}

func (t *JudgeActionTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
	if ttWant := vdl.TypeOf((*JudgeAction)(nil)); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}

	return t, nil
}
func (t *JudgeActionTarget) StartField(name string) (key, field vdl.Target, _ error) {
	t.fieldName = name
	switch name {
	case "PlayerNum":
		val := int32(0)
		return nil, &vdl.Int32Target{Value: &val}, nil
	case "OpponentName":
		val := ""
		return nil, &vdl.StringTarget{Value: &val}, nil
	case "MoveOptions":
		val := []string(nil)
		return nil, &vdl.StringSliceTarget{Value: &val}, nil
	case "RoundResult":
		val := Round{}
		return nil, &RoundTarget{Value: &val}, nil
	case "Score":
		val := ScoreCard{}
		return nil, &ScoreCardTarget{Value: &val}, nil
	default:
		return nil, nil, fmt.Errorf("field %s not in union v.io/x/ref/examples/rps.JudgeAction", name)
	}
}
func (t *JudgeActionTarget) FinishField(_, fieldTarget vdl.Target) error {
	switch t.fieldName {
	case "PlayerNum":
		*t.Value = JudgeActionPlayerNum{*(fieldTarget.(*vdl.Int32Target)).Value}
	case "OpponentName":
		*t.Value = JudgeActionOpponentName{*(fieldTarget.(*vdl.StringTarget)).Value}
	case "MoveOptions":
		*t.Value = JudgeActionMoveOptions{*(fieldTarget.(*vdl.StringSliceTarget)).Value}
	case "RoundResult":
		*t.Value = JudgeActionRoundResult{*(fieldTarget.(*RoundTarget)).Value}
	case "Score":
		*t.Value = JudgeActionScore{*(fieldTarget.(*ScoreCardTarget)).Value}
	}
	return nil
}
func (t *JudgeActionTarget) FinishFields(_ vdl.FieldsTarget) error {

	return nil
}
func (t *JudgeActionTarget) FromZero(tt *vdl.Type) error {
	*t.Value = JudgeAction(JudgeActionPlayerNum{})
	return nil
}

type judgeActionTargetFactory struct{}

func (t judgeActionTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
	if typedUnion, ok := union.(*JudgeAction); ok {
		return &JudgeActionTarget{Value: typedUnion}, nil
	}
	return nil, fmt.Errorf("got %T, want *JudgeAction", union)
}

// PlayResult is the value returned by the Play method. It indicates the outcome of the game.
type PlayResult struct {
	YouWon bool // True if the player receiving the result won the game.
}

func (PlayResult) __VDLReflect(struct {
	Name string `vdl:"v.io/x/ref/examples/rps.PlayResult"`
}) {
}

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

		var4 := (m.YouWon == false)
		if var4 {
			if err := fieldTarget3.FromZero(tt.NonOptional().Field(0).Type); err != nil {
				return err
			}
		} else {
			if err := fieldTarget3.FromBool(bool(m.YouWon), 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 *PlayResult) MakeVDLTarget() vdl.Target {
	return &PlayResultTarget{Value: m}
}

type PlayResultTarget struct {
	Value        *PlayResult
	youWonTarget vdl.BoolTarget
	vdl.TargetBase
	vdl.FieldsTargetBase
}

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

	if ttWant := vdl.TypeOf((*PlayResult)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
		return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
	}
	return t, nil
}
func (t *PlayResultTarget) StartField(name string) (key, field vdl.Target, _ error) {
	switch name {
	case "YouWon":
		t.youWonTarget.Value = &t.Value.YouWon
		target, err := &t.youWonTarget, error(nil)
		return nil, target, err
	default:
		return nil, nil, fmt.Errorf("field %s not in struct v.io/x/ref/examples/rps.PlayResult", name)
	}
}
func (t *PlayResultTarget) FinishField(_, _ vdl.Target) error {
	return nil
}
func (t *PlayResultTarget) FinishFields(_ vdl.FieldsTarget) error {

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

//////////////////////////////////////////////////
// Const definitions

const Classic = GameTypeTag(0)     // Rock-Paper-Scissors
const LizardSpock = GameTypeTag(1) // Rock-Paper-Scissors-Lizard-Spock
const Draw = WinnerTag(0)
const Player1 = WinnerTag(1)
const Player2 = WinnerTag(2)

//////////////////////////////////////////////////
// Interface definitions

// JudgeClientMethods is the client interface
// containing Judge methods.
type JudgeClientMethods interface {
	// CreateGame creates a new game with the given game options and returns a game
	// identifier that can be used by the players to join the game.
	CreateGame(_ *context.T, Opts GameOptions, _ ...rpc.CallOpt) (GameId, error)
	// Play lets a player join an existing game and play.
	Play(_ *context.T, Id GameId, _ ...rpc.CallOpt) (JudgePlayClientCall, error)
}

// JudgeClientStub adds universal methods to JudgeClientMethods.
type JudgeClientStub interface {
	JudgeClientMethods
	rpc.UniversalServiceMethods
}

// JudgeClient returns a client stub for Judge.
func JudgeClient(name string) JudgeClientStub {
	return implJudgeClientStub{name}
}

type implJudgeClientStub struct {
	name string
}

func (c implJudgeClientStub) CreateGame(ctx *context.T, i0 GameOptions, opts ...rpc.CallOpt) (o0 GameId, err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "CreateGame", []interface{}{i0}, []interface{}{&o0}, opts...)
	return
}

func (c implJudgeClientStub) Play(ctx *context.T, i0 GameId, opts ...rpc.CallOpt) (ocall JudgePlayClientCall, err error) {
	var call rpc.ClientCall
	if call, err = v23.GetClient(ctx).StartCall(ctx, c.name, "Play", []interface{}{i0}, opts...); err != nil {
		return
	}
	ocall = &implJudgePlayClientCall{ClientCall: call}
	return
}

// JudgePlayClientStream is the client stream for Judge.Play.
type JudgePlayClientStream interface {
	// RecvStream returns the receiver side of the Judge.Play 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() JudgeAction
		// Err returns any error encountered by Advance.  Never blocks.
		Err() error
	}
	// SendStream returns the send side of the Judge.Play 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 PlayerAction) 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
	}
}

// JudgePlayClientCall represents the call returned from Judge.Play.
type JudgePlayClientCall interface {
	JudgePlayClientStream
	// 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() (PlayResult, error)
}

type implJudgePlayClientCall struct {
	rpc.ClientCall
	valRecv JudgeAction
	errRecv error
}

func (c *implJudgePlayClientCall) RecvStream() interface {
	Advance() bool
	Value() JudgeAction
	Err() error
} {
	return implJudgePlayClientCallRecv{c}
}

type implJudgePlayClientCallRecv struct {
	c *implJudgePlayClientCall
}

func (c implJudgePlayClientCallRecv) Advance() bool {
	c.c.errRecv = c.c.Recv(&c.c.valRecv)
	return c.c.errRecv == nil
}
func (c implJudgePlayClientCallRecv) Value() JudgeAction {
	return c.c.valRecv
}
func (c implJudgePlayClientCallRecv) Err() error {
	if c.c.errRecv == io.EOF {
		return nil
	}
	return c.c.errRecv
}
func (c *implJudgePlayClientCall) SendStream() interface {
	Send(item PlayerAction) error
	Close() error
} {
	return implJudgePlayClientCallSend{c}
}

type implJudgePlayClientCallSend struct {
	c *implJudgePlayClientCall
}

func (c implJudgePlayClientCallSend) Send(item PlayerAction) error {
	return c.c.Send(item)
}
func (c implJudgePlayClientCallSend) Close() error {
	return c.c.CloseSend()
}
func (c *implJudgePlayClientCall) Finish() (o0 PlayResult, err error) {
	err = c.ClientCall.Finish(&o0)
	return
}

// JudgeServerMethods is the interface a server writer
// implements for Judge.
type JudgeServerMethods interface {
	// CreateGame creates a new game with the given game options and returns a game
	// identifier that can be used by the players to join the game.
	CreateGame(_ *context.T, _ rpc.ServerCall, Opts GameOptions) (GameId, error)
	// Play lets a player join an existing game and play.
	Play(_ *context.T, _ JudgePlayServerCall, Id GameId) (PlayResult, error)
}

// JudgeServerStubMethods is the server interface containing
// Judge methods, as expected by rpc.Server.
// The only difference between this interface and JudgeServerMethods
// is the streaming methods.
type JudgeServerStubMethods interface {
	// CreateGame creates a new game with the given game options and returns a game
	// identifier that can be used by the players to join the game.
	CreateGame(_ *context.T, _ rpc.ServerCall, Opts GameOptions) (GameId, error)
	// Play lets a player join an existing game and play.
	Play(_ *context.T, _ *JudgePlayServerCallStub, Id GameId) (PlayResult, error)
}

// JudgeServerStub adds universal methods to JudgeServerStubMethods.
type JudgeServerStub interface {
	JudgeServerStubMethods
	// Describe the Judge interfaces.
	Describe__() []rpc.InterfaceDesc
}

// JudgeServer returns a server stub for Judge.
// It converts an implementation of JudgeServerMethods into
// an object that may be used by rpc.Server.
func JudgeServer(impl JudgeServerMethods) JudgeServerStub {
	stub := implJudgeServerStub{
		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 implJudgeServerStub struct {
	impl JudgeServerMethods
	gs   *rpc.GlobState
}

func (s implJudgeServerStub) CreateGame(ctx *context.T, call rpc.ServerCall, i0 GameOptions) (GameId, error) {
	return s.impl.CreateGame(ctx, call, i0)
}

func (s implJudgeServerStub) Play(ctx *context.T, call *JudgePlayServerCallStub, i0 GameId) (PlayResult, error) {
	return s.impl.Play(ctx, call, i0)
}

func (s implJudgeServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implJudgeServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{JudgeDesc}
}

// JudgeDesc describes the Judge interface.
var JudgeDesc rpc.InterfaceDesc = descJudge

// descJudge hides the desc to keep godoc clean.
var descJudge = rpc.InterfaceDesc{
	Name:    "Judge",
	PkgPath: "v.io/x/ref/examples/rps",
	Methods: []rpc.MethodDesc{
		{
			Name: "CreateGame",
			Doc:  "// CreateGame creates a new game with the given game options and returns a game\n// identifier that can be used by the players to join the game.",
			InArgs: []rpc.ArgDesc{
				{"Opts", ``}, // GameOptions
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // GameId
			},
			Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
		},
		{
			Name: "Play",
			Doc:  "// Play lets a player join an existing game and play.",
			InArgs: []rpc.ArgDesc{
				{"Id", ``}, // GameId
			},
			OutArgs: []rpc.ArgDesc{
				{"", ``}, // PlayResult
			},
			Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
		},
	},
}

// JudgePlayServerStream is the server stream for Judge.Play.
type JudgePlayServerStream interface {
	// RecvStream returns the receiver side of the Judge.Play 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() PlayerAction
		// Err returns any error encountered by Advance.  Never blocks.
		Err() error
	}
	// SendStream returns the send side of the Judge.Play 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 JudgeAction) error
	}
}

// JudgePlayServerCall represents the context passed to Judge.Play.
type JudgePlayServerCall interface {
	rpc.ServerCall
	JudgePlayServerStream
}

// JudgePlayServerCallStub is a wrapper that converts rpc.StreamServerCall into
// a typesafe stub that implements JudgePlayServerCall.
type JudgePlayServerCallStub struct {
	rpc.StreamServerCall
	valRecv PlayerAction
	errRecv error
}

// Init initializes JudgePlayServerCallStub from rpc.StreamServerCall.
func (s *JudgePlayServerCallStub) Init(call rpc.StreamServerCall) {
	s.StreamServerCall = call
}

// RecvStream returns the receiver side of the Judge.Play server stream.
func (s *JudgePlayServerCallStub) RecvStream() interface {
	Advance() bool
	Value() PlayerAction
	Err() error
} {
	return implJudgePlayServerCallRecv{s}
}

type implJudgePlayServerCallRecv struct {
	s *JudgePlayServerCallStub
}

func (s implJudgePlayServerCallRecv) Advance() bool {
	s.s.errRecv = s.s.Recv(&s.s.valRecv)
	return s.s.errRecv == nil
}
func (s implJudgePlayServerCallRecv) Value() PlayerAction {
	return s.s.valRecv
}
func (s implJudgePlayServerCallRecv) Err() error {
	if s.s.errRecv == io.EOF {
		return nil
	}
	return s.s.errRecv
}

// SendStream returns the send side of the Judge.Play server stream.
func (s *JudgePlayServerCallStub) SendStream() interface {
	Send(item JudgeAction) error
} {
	return implJudgePlayServerCallSend{s}
}

type implJudgePlayServerCallSend struct {
	s *JudgePlayServerCallStub
}

func (s implJudgePlayServerCallSend) Send(item JudgeAction) error {
	return s.s.Send(item)
}

// PlayerClientMethods is the client interface
// containing Player methods.
//
// Player can receive challenges from other players.
type PlayerClientMethods interface {
	// Challenge is used by other players to challenge this player to a game. If
	// the challenge is accepted, the method returns nil.
	Challenge(_ *context.T, Address string, Id GameId, Opts GameOptions, _ ...rpc.CallOpt) error
}

// PlayerClientStub adds universal methods to PlayerClientMethods.
type PlayerClientStub interface {
	PlayerClientMethods
	rpc.UniversalServiceMethods
}

// PlayerClient returns a client stub for Player.
func PlayerClient(name string) PlayerClientStub {
	return implPlayerClientStub{name}
}

type implPlayerClientStub struct {
	name string
}

func (c implPlayerClientStub) Challenge(ctx *context.T, i0 string, i1 GameId, i2 GameOptions, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "Challenge", []interface{}{i0, i1, i2}, nil, opts...)
	return
}

// PlayerServerMethods is the interface a server writer
// implements for Player.
//
// Player can receive challenges from other players.
type PlayerServerMethods interface {
	// Challenge is used by other players to challenge this player to a game. If
	// the challenge is accepted, the method returns nil.
	Challenge(_ *context.T, _ rpc.ServerCall, Address string, Id GameId, Opts GameOptions) error
}

// PlayerServerStubMethods is the server interface containing
// Player methods, as expected by rpc.Server.
// There is no difference between this interface and PlayerServerMethods
// since there are no streaming methods.
type PlayerServerStubMethods PlayerServerMethods

// PlayerServerStub adds universal methods to PlayerServerStubMethods.
type PlayerServerStub interface {
	PlayerServerStubMethods
	// Describe the Player interfaces.
	Describe__() []rpc.InterfaceDesc
}

// PlayerServer returns a server stub for Player.
// It converts an implementation of PlayerServerMethods into
// an object that may be used by rpc.Server.
func PlayerServer(impl PlayerServerMethods) PlayerServerStub {
	stub := implPlayerServerStub{
		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 implPlayerServerStub struct {
	impl PlayerServerMethods
	gs   *rpc.GlobState
}

func (s implPlayerServerStub) Challenge(ctx *context.T, call rpc.ServerCall, i0 string, i1 GameId, i2 GameOptions) error {
	return s.impl.Challenge(ctx, call, i0, i1, i2)
}

func (s implPlayerServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implPlayerServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{PlayerDesc}
}

// PlayerDesc describes the Player interface.
var PlayerDesc rpc.InterfaceDesc = descPlayer

// descPlayer hides the desc to keep godoc clean.
var descPlayer = rpc.InterfaceDesc{
	Name:    "Player",
	PkgPath: "v.io/x/ref/examples/rps",
	Doc:     "// Player can receive challenges from other players.",
	Methods: []rpc.MethodDesc{
		{
			Name: "Challenge",
			Doc:  "// Challenge is used by other players to challenge this player to a game. If\n// the challenge is accepted, the method returns nil.",
			InArgs: []rpc.ArgDesc{
				{"Address", ``}, // string
				{"Id", ``},      // GameId
				{"Opts", ``},    // GameOptions
			},
			Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
		},
	},
}

// ScoreKeeperClientMethods is the client interface
// containing ScoreKeeper methods.
//
// ScoreKeeper receives the outcome of games from Judges.
type ScoreKeeperClientMethods interface {
	Record(_ *context.T, Score ScoreCard, _ ...rpc.CallOpt) error
}

// ScoreKeeperClientStub adds universal methods to ScoreKeeperClientMethods.
type ScoreKeeperClientStub interface {
	ScoreKeeperClientMethods
	rpc.UniversalServiceMethods
}

// ScoreKeeperClient returns a client stub for ScoreKeeper.
func ScoreKeeperClient(name string) ScoreKeeperClientStub {
	return implScoreKeeperClientStub{name}
}

type implScoreKeeperClientStub struct {
	name string
}

func (c implScoreKeeperClientStub) Record(ctx *context.T, i0 ScoreCard, opts ...rpc.CallOpt) (err error) {
	err = v23.GetClient(ctx).Call(ctx, c.name, "Record", []interface{}{i0}, nil, opts...)
	return
}

// ScoreKeeperServerMethods is the interface a server writer
// implements for ScoreKeeper.
//
// ScoreKeeper receives the outcome of games from Judges.
type ScoreKeeperServerMethods interface {
	Record(_ *context.T, _ rpc.ServerCall, Score ScoreCard) error
}

// ScoreKeeperServerStubMethods is the server interface containing
// ScoreKeeper methods, as expected by rpc.Server.
// There is no difference between this interface and ScoreKeeperServerMethods
// since there are no streaming methods.
type ScoreKeeperServerStubMethods ScoreKeeperServerMethods

// ScoreKeeperServerStub adds universal methods to ScoreKeeperServerStubMethods.
type ScoreKeeperServerStub interface {
	ScoreKeeperServerStubMethods
	// Describe the ScoreKeeper interfaces.
	Describe__() []rpc.InterfaceDesc
}

// ScoreKeeperServer returns a server stub for ScoreKeeper.
// It converts an implementation of ScoreKeeperServerMethods into
// an object that may be used by rpc.Server.
func ScoreKeeperServer(impl ScoreKeeperServerMethods) ScoreKeeperServerStub {
	stub := implScoreKeeperServerStub{
		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 implScoreKeeperServerStub struct {
	impl ScoreKeeperServerMethods
	gs   *rpc.GlobState
}

func (s implScoreKeeperServerStub) Record(ctx *context.T, call rpc.ServerCall, i0 ScoreCard) error {
	return s.impl.Record(ctx, call, i0)
}

func (s implScoreKeeperServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implScoreKeeperServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{ScoreKeeperDesc}
}

// ScoreKeeperDesc describes the ScoreKeeper interface.
var ScoreKeeperDesc rpc.InterfaceDesc = descScoreKeeper

// descScoreKeeper hides the desc to keep godoc clean.
var descScoreKeeper = rpc.InterfaceDesc{
	Name:    "ScoreKeeper",
	PkgPath: "v.io/x/ref/examples/rps",
	Doc:     "// ScoreKeeper receives the outcome of games from Judges.",
	Methods: []rpc.MethodDesc{
		{
			Name: "Record",
			InArgs: []rpc.ArgDesc{
				{"Score", ``}, // ScoreCard
			},
			Tags: []*vdl.Value{vdl.ValueOf(access.Tag("Write"))},
		},
	},
}

// RockPaperScissorsClientMethods is the client interface
// containing RockPaperScissors methods.
type RockPaperScissorsClientMethods interface {
	JudgeClientMethods
	// Player can receive challenges from other players.
	PlayerClientMethods
	// ScoreKeeper receives the outcome of games from Judges.
	ScoreKeeperClientMethods
}

// RockPaperScissorsClientStub adds universal methods to RockPaperScissorsClientMethods.
type RockPaperScissorsClientStub interface {
	RockPaperScissorsClientMethods
	rpc.UniversalServiceMethods
}

// RockPaperScissorsClient returns a client stub for RockPaperScissors.
func RockPaperScissorsClient(name string) RockPaperScissorsClientStub {
	return implRockPaperScissorsClientStub{name, JudgeClient(name), PlayerClient(name), ScoreKeeperClient(name)}
}

type implRockPaperScissorsClientStub struct {
	name string

	JudgeClientStub
	PlayerClientStub
	ScoreKeeperClientStub
}

// RockPaperScissorsServerMethods is the interface a server writer
// implements for RockPaperScissors.
type RockPaperScissorsServerMethods interface {
	JudgeServerMethods
	// Player can receive challenges from other players.
	PlayerServerMethods
	// ScoreKeeper receives the outcome of games from Judges.
	ScoreKeeperServerMethods
}

// RockPaperScissorsServerStubMethods is the server interface containing
// RockPaperScissors methods, as expected by rpc.Server.
// The only difference between this interface and RockPaperScissorsServerMethods
// is the streaming methods.
type RockPaperScissorsServerStubMethods interface {
	JudgeServerStubMethods
	// Player can receive challenges from other players.
	PlayerServerStubMethods
	// ScoreKeeper receives the outcome of games from Judges.
	ScoreKeeperServerStubMethods
}

// RockPaperScissorsServerStub adds universal methods to RockPaperScissorsServerStubMethods.
type RockPaperScissorsServerStub interface {
	RockPaperScissorsServerStubMethods
	// Describe the RockPaperScissors interfaces.
	Describe__() []rpc.InterfaceDesc
}

// RockPaperScissorsServer returns a server stub for RockPaperScissors.
// It converts an implementation of RockPaperScissorsServerMethods into
// an object that may be used by rpc.Server.
func RockPaperScissorsServer(impl RockPaperScissorsServerMethods) RockPaperScissorsServerStub {
	stub := implRockPaperScissorsServerStub{
		impl:                  impl,
		JudgeServerStub:       JudgeServer(impl),
		PlayerServerStub:      PlayerServer(impl),
		ScoreKeeperServerStub: ScoreKeeperServer(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 implRockPaperScissorsServerStub struct {
	impl RockPaperScissorsServerMethods
	JudgeServerStub
	PlayerServerStub
	ScoreKeeperServerStub
	gs *rpc.GlobState
}

func (s implRockPaperScissorsServerStub) Globber() *rpc.GlobState {
	return s.gs
}

func (s implRockPaperScissorsServerStub) Describe__() []rpc.InterfaceDesc {
	return []rpc.InterfaceDesc{RockPaperScissorsDesc, JudgeDesc, PlayerDesc, ScoreKeeperDesc}
}

// RockPaperScissorsDesc describes the RockPaperScissors interface.
var RockPaperScissorsDesc rpc.InterfaceDesc = descRockPaperScissors

// descRockPaperScissors hides the desc to keep godoc clean.
var descRockPaperScissors = rpc.InterfaceDesc{
	Name:    "RockPaperScissors",
	PkgPath: "v.io/x/ref/examples/rps",
	Embeds: []rpc.EmbedDesc{
		{"Judge", "v.io/x/ref/examples/rps", ``},
		{"Player", "v.io/x/ref/examples/rps", "// Player can receive challenges from other players."},
		{"ScoreKeeper", "v.io/x/ref/examples/rps", "// ScoreKeeper receives the outcome of games from Judges."},
	},
}

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((*GameId)(nil))
	vdl.Register((*GameTypeTag)(nil))
	vdl.Register((*GameOptions)(nil))
	vdl.Register((*unused)(nil))
	vdl.Register((*PlayerAction)(nil))
	vdl.Register((*PlayersMoves)(nil))
	vdl.Register((*WinnerTag)(nil))
	vdl.Register((*Round)(nil))
	vdl.Register((*ScoreCard)(nil))
	vdl.Register((*JudgeAction)(nil))
	vdl.Register((*PlayResult)(nil))

	return struct{}{}
}