// Autogenerated by Thrift Compiler (1.0.0-dev)
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING

package AgentVsAgent

import (
	"fmt"
	"git.apache.org/thrift.git/lib/go/thrift"
	"math"
)

// (needed to ensure safety because of naive import list construction.)
var _ = math.MinInt32
var _ = thrift.ZERO
var _ = fmt.Printf

var GoUnusedProtection__ int

type Suit int64

const (
	Suit_CLUBS    Suit = 21
	Suit_DIAMONDS Suit = 22
	Suit_SPADES   Suit = 23
	Suit_HEARTS   Suit = 24
)

func (p Suit) String() string {
	switch p {
	case Suit_CLUBS:
		return "Suit_CLUBS"
	case Suit_DIAMONDS:
		return "Suit_DIAMONDS"
	case Suit_SPADES:
		return "Suit_SPADES"
	case Suit_HEARTS:
		return "Suit_HEARTS"
	}
	return "<UNSET>"
}

func SuitFromString(s string) (Suit, error) {
	switch s {
	case "Suit_CLUBS":
		return Suit_CLUBS, nil
	case "Suit_DIAMONDS":
		return Suit_DIAMONDS, nil
	case "Suit_SPADES":
		return Suit_SPADES, nil
	case "Suit_HEARTS":
		return Suit_HEARTS, nil
	}
	return Suit(math.MinInt32 - 1), fmt.Errorf("not a valid Suit string")
}

type Rank int64

const (
	Rank_TWO   Rank = 2
	Rank_THREE Rank = 3
	Rank_FOUR  Rank = 4
	Rank_FIVE  Rank = 5
	Rank_SIX   Rank = 6
	Rank_SEVEN Rank = 7
	Rank_EIGHT Rank = 8
	Rank_NINE  Rank = 9
	Rank_TEN   Rank = 10
	Rank_JACK  Rank = 11
	Rank_QUEEN Rank = 12
	Rank_KING  Rank = 13
	Rank_ACE   Rank = 14
)

func (p Rank) String() string {
	switch p {
	case Rank_TWO:
		return "Rank_TWO"
	case Rank_THREE:
		return "Rank_THREE"
	case Rank_FOUR:
		return "Rank_FOUR"
	case Rank_FIVE:
		return "Rank_FIVE"
	case Rank_SIX:
		return "Rank_SIX"
	case Rank_SEVEN:
		return "Rank_SEVEN"
	case Rank_EIGHT:
		return "Rank_EIGHT"
	case Rank_NINE:
		return "Rank_NINE"
	case Rank_TEN:
		return "Rank_TEN"
	case Rank_JACK:
		return "Rank_JACK"
	case Rank_QUEEN:
		return "Rank_QUEEN"
	case Rank_KING:
		return "Rank_KING"
	case Rank_ACE:
		return "Rank_ACE"
	}
	return "<UNSET>"
}

func RankFromString(s string) (Rank, error) {
	switch s {
	case "Rank_TWO":
		return Rank_TWO, nil
	case "Rank_THREE":
		return Rank_THREE, nil
	case "Rank_FOUR":
		return Rank_FOUR, nil
	case "Rank_FIVE":
		return Rank_FIVE, nil
	case "Rank_SIX":
		return Rank_SIX, nil
	case "Rank_SEVEN":
		return Rank_SEVEN, nil
	case "Rank_EIGHT":
		return Rank_EIGHT, nil
	case "Rank_NINE":
		return Rank_NINE, nil
	case "Rank_TEN":
		return Rank_TEN, nil
	case "Rank_JACK":
		return Rank_JACK, nil
	case "Rank_QUEEN":
		return Rank_QUEEN, nil
	case "Rank_KING":
		return Rank_KING, nil
	case "Rank_ACE":
		return Rank_ACE, nil
	}
	return Rank(math.MinInt32 - 1), fmt.Errorf("not a valid Rank string")
}

type GameStatus int64

const (
	GameStatus_NEXT_ROUND GameStatus = 1
	GameStatus_END_GAME   GameStatus = 2
)

func (p GameStatus) String() string {
	switch p {
	case GameStatus_NEXT_ROUND:
		return "GameStatus_NEXT_ROUND"
	case GameStatus_END_GAME:
		return "GameStatus_END_GAME"
	}
	return "<UNSET>"
}

func GameStatusFromString(s string) (GameStatus, error) {
	switch s {
	case "GameStatus_NEXT_ROUND":
		return GameStatus_NEXT_ROUND, nil
	case "GameStatus_END_GAME":
		return GameStatus_END_GAME, nil
	}
	return GameStatus(math.MinInt32 - 1), fmt.Errorf("not a valid GameStatus string")
}

type Position string

type Score int32

type Card struct {
	Suit Suit `thrift:"suit,1,required"`
	Rank Rank `thrift:"rank,2,required"`
}

func NewCard() *Card {
	return &Card{
		Suit: math.MinInt32 - 1, // unset sentinal value

		Rank: math.MinInt32 - 1, // unset sentinal value
	}
}

func (p *Card) IsSetSuit() bool {
	return int64(p.Suit) != math.MinInt32-1
}

func (p *Card) IsSetRank() bool {
	return int64(p.Rank) != math.MinInt32-1
}

func (p *Card) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error", p)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.readField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.readField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *Card) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s")
	} else {
		p.Suit = Suit(v)
	}
	return nil
}

func (p *Card) readField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 2: %s")
	} else {
		p.Rank = Rank(v)
	}
	return nil
}

func (p *Card) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Card"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("%T write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("%T write struct stop error: %s", err)
	}
	return nil
}

func (p *Card) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuit() {
		if err := oprot.WriteFieldBegin("suit", thrift.I32, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:suit: %s", p, err)
		}
		if err := oprot.WriteI32(int32(p.Suit)); err != nil {
			return fmt.Errorf("%T.suit (1) field write error: %s", p)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:suit: %s", p, err)
		}
	}
	return err
}

func (p *Card) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetRank() {
		if err := oprot.WriteFieldBegin("rank", thrift.I32, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:rank: %s", p, err)
		}
		if err := oprot.WriteI32(int32(p.Rank)); err != nil {
			return fmt.Errorf("%T.rank (2) field write error: %s", p)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:rank: %s", p, err)
		}
	}
	return err
}

func (p *Card) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("Card(%+v)", *p)
}

type Ticket struct {
	AgentId string `thrift:"agentId,1,required"`
}

func NewTicket() *Ticket {
	return &Ticket{}
}

func (p *Ticket) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error", p)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.readField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *Ticket) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s")
	} else {
		p.AgentId = v
	}
	return nil
}

func (p *Ticket) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Ticket"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("%T write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("%T write struct stop error: %s", err)
	}
	return nil
}

func (p *Ticket) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("agentId", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:agentId: %s", p, err)
	}
	if err := oprot.WriteString(string(p.AgentId)); err != nil {
		return fmt.Errorf("%T.agentId (1) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:agentId: %s", p, err)
	}
	return err
}

func (p *Ticket) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("Ticket(%+v)", *p)
}

type EntryRequest struct {
	Version string `thrift:"version,1,required"`
}

func NewEntryRequest() *EntryRequest {
	return &EntryRequest{
		Version: "0.0.16",
	}
}

func (p *EntryRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error", p)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.readField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *EntryRequest) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s")
	} else {
		p.Version = v
	}
	return nil
}

func (p *EntryRequest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("EntryRequest"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("%T write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("%T write struct stop error: %s", err)
	}
	return nil
}

func (p *EntryRequest) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("version", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:version: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Version)); err != nil {
		return fmt.Errorf("%T.version (1) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:version: %s", p, err)
	}
	return err
}

func (p *EntryRequest) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("EntryRequest(%+v)", *p)
}

type EntryResponse struct {
	Ticket  *Ticket `thrift:"ticket,1"`
	Message string  `thrift:"message,2"`
}

func NewEntryResponse() *EntryResponse {
	return &EntryResponse{}
}

func (p *EntryResponse) IsSetTicket() bool {
	return p.Ticket != nil
}

func (p *EntryResponse) IsSetMessage() bool {
	return p.Message != ""
}

func (p *EntryResponse) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error", p)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.readField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.readField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *EntryResponse) readField1(iprot thrift.TProtocol) error {
	p.Ticket = NewTicket()
	if err := p.Ticket.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.Ticket)
	}
	return nil
}

func (p *EntryResponse) readField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s")
	} else {
		p.Message = v
	}
	return nil
}

func (p *EntryResponse) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("EntryResponse"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("%T write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("%T write struct stop error: %s", err)
	}
	return nil
}

func (p *EntryResponse) writeField1(oprot thrift.TProtocol) (err error) {
	if p.Ticket != nil {
		if p.IsSetTicket() {
			if err := oprot.WriteFieldBegin("ticket", thrift.STRUCT, 1); err != nil {
				return fmt.Errorf("%T write field begin error 1:ticket: %s", p, err)
			}
			if err := p.Ticket.Write(oprot); err != nil {
				return fmt.Errorf("%T error writing struct: %s", p.Ticket)
			}
			if err := oprot.WriteFieldEnd(); err != nil {
				return fmt.Errorf("%T write field end error 1:ticket: %s", p, err)
			}
		}
	}
	return err
}

func (p *EntryResponse) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetMessage() {
		if err := oprot.WriteFieldBegin("message", thrift.STRING, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:message: %s", p, err)
		}
		if err := oprot.WriteString(string(p.Message)); err != nil {
			return fmt.Errorf("%T.message (2) field write error: %s", p)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:message: %s", p, err)
		}
	}
	return err
}

func (p *EntryResponse) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("EntryResponse(%+v)", *p)
}

type GameInfo struct {
	Position Position `thrift:"position,1,required"`
}

func NewGameInfo() *GameInfo {
	return &GameInfo{}
}

func (p *GameInfo) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error", p)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.readField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *GameInfo) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s")
	} else {
		p.Position = Position(v)
	}
	return nil
}

func (p *GameInfo) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("GameInfo"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("%T write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("%T write struct stop error: %s", err)
	}
	return nil
}

func (p *GameInfo) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("position", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:position: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Position)); err != nil {
		return fmt.Errorf("%T.position (1) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:position: %s", p, err)
	}
	return err
}

func (p *GameInfo) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("GameInfo(%+v)", *p)
}

type Trick struct {
	Leader Position `thrift:"leader,1,required"`
	Played []*Card  `thrift:"played,2,required"`
}

func NewTrick() *Trick {
	return &Trick{}
}

func (p *Trick) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error", p)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.readField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.readField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *Trick) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s")
	} else {
		p.Leader = Position(v)
	}
	return nil
}

func (p *Trick) readField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list being: %s")
	}
	p.Played = make([]*Card, 0, size)
	for i := 0; i < size; i++ {
		_elem0 := NewCard()
		if err := _elem0.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem0)
		}
		p.Played = append(p.Played, _elem0)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s")
	}
	return nil
}

func (p *Trick) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Trick"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("%T write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("%T write struct stop error: %s", err)
	}
	return nil
}

func (p *Trick) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("leader", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:leader: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Leader)); err != nil {
		return fmt.Errorf("%T.leader (1) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:leader: %s", p, err)
	}
	return err
}

func (p *Trick) writeField2(oprot thrift.TProtocol) (err error) {
	if p.Played != nil {
		if err := oprot.WriteFieldBegin("played", thrift.LIST, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:played: %s", p, err)
		}
		if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Played)); err != nil {
			return fmt.Errorf("error writing list begin: %s")
		}
		for _, v := range p.Played {
			if err := v.Write(oprot); err != nil {
				return fmt.Errorf("%T error writing struct: %s", v)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return fmt.Errorf("error writing list end: %s")
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:played: %s", p, err)
		}
	}
	return err
}

func (p *Trick) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("Trick(%+v)", *p)
}

type RoundResult struct {
	North  Score      `thrift:"north,1,required"`
	East   Score      `thrift:"east,2,required"`
	South  Score      `thrift:"south,3,required"`
	West   Score      `thrift:"west,4,required"`
	Status GameStatus `thrift:"status,5,required"`
}

func NewRoundResult() *RoundResult {
	return &RoundResult{
		Status: math.MinInt32 - 1, // unset sentinal value
	}
}

func (p *RoundResult) IsSetStatus() bool {
	return int64(p.Status) != math.MinInt32-1
}

func (p *RoundResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error", p)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.readField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.readField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.readField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.readField4(iprot); err != nil {
				return err
			}
		case 5:
			if err := p.readField5(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *RoundResult) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s")
	} else {
		p.North = Score(v)
	}
	return nil
}

func (p *RoundResult) readField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 2: %s")
	} else {
		p.East = Score(v)
	}
	return nil
}

func (p *RoundResult) readField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 3: %s")
	} else {
		p.South = Score(v)
	}
	return nil
}

func (p *RoundResult) readField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 4: %s")
	} else {
		p.West = Score(v)
	}
	return nil
}

func (p *RoundResult) readField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 5: %s")
	} else {
		p.Status = GameStatus(v)
	}
	return nil
}

func (p *RoundResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("RoundResult"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField5(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("%T write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("%T write struct stop error: %s", err)
	}
	return nil
}

func (p *RoundResult) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("north", thrift.I32, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:north: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.North)); err != nil {
		return fmt.Errorf("%T.north (1) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:north: %s", p, err)
	}
	return err
}

func (p *RoundResult) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("east", thrift.I32, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:east: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.East)); err != nil {
		return fmt.Errorf("%T.east (2) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:east: %s", p, err)
	}
	return err
}

func (p *RoundResult) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("south", thrift.I32, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:south: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.South)); err != nil {
		return fmt.Errorf("%T.south (3) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:south: %s", p, err)
	}
	return err
}

func (p *RoundResult) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("west", thrift.I32, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:west: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.West)); err != nil {
		return fmt.Errorf("%T.west (4) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:west: %s", p, err)
	}
	return err
}

func (p *RoundResult) writeField5(oprot thrift.TProtocol) (err error) {
	if p.IsSetStatus() {
		if err := oprot.WriteFieldBegin("status", thrift.I32, 5); err != nil {
			return fmt.Errorf("%T write field begin error 5:status: %s", p, err)
		}
		if err := oprot.WriteI32(int32(p.Status)); err != nil {
			return fmt.Errorf("%T.status (5) field write error: %s", p)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 5:status: %s", p, err)
		}
	}
	return err
}

func (p *RoundResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("RoundResult(%+v)", *p)
}

type GameResult struct {
	North Score `thrift:"north,1,required"`
	East  Score `thrift:"east,2,required"`
	South Score `thrift:"south,3,required"`
	West  Score `thrift:"west,4,required"`
}

func NewGameResult() *GameResult {
	return &GameResult{}
}

func (p *GameResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error", p)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.readField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.readField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.readField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.readField4(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *GameResult) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 1: %s")
	} else {
		p.North = Score(v)
	}
	return nil
}

func (p *GameResult) readField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 2: %s")
	} else {
		p.East = Score(v)
	}
	return nil
}

func (p *GameResult) readField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 3: %s")
	} else {
		p.South = Score(v)
	}
	return nil
}

func (p *GameResult) readField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return fmt.Errorf("error reading field 4: %s")
	} else {
		p.West = Score(v)
	}
	return nil
}

func (p *GameResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("GameResult"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("%T write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("%T write struct stop error: %s", err)
	}
	return nil
}

func (p *GameResult) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("north", thrift.I32, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:north: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.North)); err != nil {
		return fmt.Errorf("%T.north (1) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:north: %s", p, err)
	}
	return err
}

func (p *GameResult) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("east", thrift.I32, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:east: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.East)); err != nil {
		return fmt.Errorf("%T.east (2) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:east: %s", p, err)
	}
	return err
}

func (p *GameResult) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("south", thrift.I32, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:south: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.South)); err != nil {
		return fmt.Errorf("%T.south (3) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:south: %s", p, err)
	}
	return err
}

func (p *GameResult) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("west", thrift.I32, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:west: %s", p, err)
	}
	if err := oprot.WriteI32(int32(p.West)); err != nil {
		return fmt.Errorf("%T.west (4) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:west: %s", p, err)
	}
	return err
}

func (p *GameResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("GameResult(%+v)", *p)
}

type GameException struct {
	Message string `thrift:"message,1,required"`
	TypeA1  string `thrift:"type,2"`
}

func NewGameException() *GameException {
	return &GameException{}
}

func (p *GameException) IsSetTypeA1() bool {
	return p.TypeA1 != ""
}

func (p *GameException) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error", p)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.readField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.readField2(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *GameException) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s")
	} else {
		p.Message = v
	}
	return nil
}

func (p *GameException) readField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s")
	} else {
		p.TypeA1 = v
	}
	return nil
}

func (p *GameException) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("GameException"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("%T write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("%T write struct stop error: %s", err)
	}
	return nil
}

func (p *GameException) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:message: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return fmt.Errorf("%T.message (1) field write error: %s", p)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:message: %s", p, err)
	}
	return err
}

func (p *GameException) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetTypeA1() {
		if err := oprot.WriteFieldBegin("type", thrift.STRING, 2); err != nil {
			return fmt.Errorf("%T write field begin error 2:type: %s", p, err)
		}
		if err := oprot.WriteString(string(p.TypeA1)); err != nil {
			return fmt.Errorf("%T.type (2) field write error: %s", p)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 2:type: %s", p, err)
		}
	}
	return err
}

func (p *GameException) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("GameException(%+v)", *p)
}