tutorial.go

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

package tutorial

import (
	"bytes"
	"context"
	"database/sql/driver"
	"errors"
	"fmt"
	"git.apache.org/thrift.git/lib/go/thrift"
	"reflect"
	"thrift_p/gen-go/shared"
)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = context.Background
var _ = reflect.DeepEqual
var _ = bytes.Equal

var _ = shared.GoUnusedProtection__

//You can define enums, which are just 32 bit integers. Values are optional
//and start at 1 if not supplied, C style again.
type Operation int64

const (
	Operation_ADD      Operation = 1
	Operation_SUBTRACT Operation = 2
	Operation_MULTIPLY Operation = 3
	Operation_DIVIDE   Operation = 4
)

func (p Operation) String() string {
	switch p {
	case Operation_ADD:
		return "ADD"
	case Operation_SUBTRACT:
		return "SUBTRACT"
	case Operation_MULTIPLY:
		return "MULTIPLY"
	case Operation_DIVIDE:
		return "DIVIDE"
	}
	return "<UNSET>"
}

func OperationFromString(s string) (Operation, error) {
	switch s {
	case "ADD":
		return Operation_ADD, nil
	case "SUBTRACT":
		return Operation_SUBTRACT, nil
	case "MULTIPLY":
		return Operation_MULTIPLY, nil
	case "DIVIDE":
		return Operation_DIVIDE, nil
	}
	return Operation(0), fmt.Errorf("not a valid Operation string")
}

func OperationPtr(v Operation) *Operation { return &v }

func (p Operation) MarshalText() ([]byte, error) {
	return []byte(p.String()), nil
}

func (p *Operation) UnmarshalText(text []byte) error {
	q, err := OperationFromString(string(text))
	if err != nil {
		return err
	}
	*p = q
	return nil
}

func (p *Operation) Scan(value interface{}) error {
	v, ok := value.(int64)
	if !ok {
		return errors.New("Scan value is not int64")
	}
	*p = Operation(v)
	return nil
}

func (p *Operation) Value() (driver.Value, error) {
	if p == nil {
		return nil, nil
	}
	return int64(*p), nil
}

//Thrift lets you do typedefs to get pretty names for your types. Standard
//C style here.
type MyInteger int32

func MyIntegerPtr(v MyInteger) *MyInteger { return &v }

// Structs are the basic complex data structures. They are comprised of fields
// which each have an integer identifier, a type, a symbolic name, and an
// optional default value.
//
// Fields can be declared "optional", which ensures they will not be included
// in the serialized output if they aren't set.  Note that this requires some
// manual management in some languages.
//
// Attributes:
//  - Num1
//  - Num2
//  - Op
//  - Comment
type Work struct {
	Num1    int32     `thrift:"num1,1" db:"num1" json:"num1"`
	Num2    int32     `thrift:"num2,2" db:"num2" json:"num2"`
	Op      Operation `thrift:"op,3" db:"op" json:"op"`
	Comment *string   `thrift:"comment,4" db:"comment" json:"comment,omitempty"`
}

func NewWork() *Work {
	return &Work{}
}

func (p *Work) GetNum1() int32 {
	return p.Num1
}

func (p *Work) GetNum2() int32 {
	return p.Num2
}

func (p *Work) GetOp() Operation {
	return p.Op
}

var Work_Comment_DEFAULT string

func (p *Work) GetComment() string {
	if !p.IsSetComment() {
		return Work_Comment_DEFAULT
	}
	return *p.Comment
}
func (p *Work) IsSetComment() bool {
	return p.Comment != nil
}

func (p *Work) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 4:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField4(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *Work) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Num1 = v
	}
	return nil
}

func (p *Work) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.Num2 = v
	}
	return nil
}

func (p *Work) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		temp := Operation(v)
		p.Op = temp
	}
	return nil
}

func (p *Work) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 4: ", err)
	} else {
		p.Comment = &v
	}
	return nil
}

func (p *Work) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Work"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *Work) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("num1", thrift.I32, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:num1: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Num1)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.num1 (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:num1: ", p), err)
	}
	return err
}

func (p *Work) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("num2", thrift.I32, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:num2: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Num2)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.num2 (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:num2: ", p), err)
	}
	return err
}

func (p *Work) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("op", thrift.I32, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:op: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Op)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.op (3) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:op: ", p), err)
	}
	return err
}

func (p *Work) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetComment() {
		if err := oprot.WriteFieldBegin("comment", thrift.STRING, 4); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:comment: ", p), err)
		}
		if err := oprot.WriteString(string(*p.Comment)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.comment (4) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 4:comment: ", p), err)
		}
	}
	return err
}

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

// Structs can also be exceptions, if they are nasty.
//
// Attributes:
//  - WhatOp
//  - Why
type InvalidOperation struct {
	WhatOp int32  `thrift:"whatOp,1" db:"whatOp" json:"whatOp"`
	Why    string `thrift:"why,2" db:"why" json:"why"`
}

func NewInvalidOperation() *InvalidOperation {
	return &InvalidOperation{}
}

func (p *InvalidOperation) GetWhatOp() int32 {
	return p.WhatOp
}

func (p *InvalidOperation) GetWhy() string {
	return p.Why
}
func (p *InvalidOperation) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *InvalidOperation) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.WhatOp = v
	}
	return nil
}

func (p *InvalidOperation) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.Why = v
	}
	return nil
}

func (p *InvalidOperation) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("InvalidOperation"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *InvalidOperation) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("whatOp", thrift.I32, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:whatOp: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.WhatOp)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.whatOp (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:whatOp: ", p), err)
	}
	return err
}

func (p *InvalidOperation) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("why", thrift.STRING, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:why: ", p), err)
	}
	if err := oprot.WriteString(string(p.Why)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.why (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:why: ", p), err)
	}
	return err
}

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

func (p *InvalidOperation) Error() string {
	return p.String()
}

type Calculator interface {
	shared.SharedService
	//Ahh, now onto the cool part, defining a service. Services just need a name
	//and can optionally inherit from another service using the extends keyword.

	// A method definition looks like C code. It has a return type, arguments,
	// and optionally a list of exceptions that it may throw. Note that argument
	// lists and exception lists are specified using the exact same syntax as
	// field lists in struct or exception definitions.
	Ping(ctx context.Context) (err error)
	// Parameters:
	//  - Num1
	//  - Num2
	Add(ctx context.Context, num1 int32, num2 int32) (r int32, err error)
	// Parameters:
	//  - Logid
	//  - W
	Calculate(ctx context.Context, logid int32, w *Work) (r int32, err error)
	// This method has a oneway modifier. That means the client only makes
	// a request and does not listen for any response at all. Oneway methods
	// must be void.
	Zip(ctx context.Context) (err error)
}

//Ahh, now onto the cool part, defining a service. Services just need a name
//and can optionally inherit from another service using the extends keyword.
type CalculatorClient struct {
	c thrift.TClient
	*shared.SharedServiceClient
}

// Deprecated: Use NewCalculator instead
func NewCalculatorClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *CalculatorClient {
	return &CalculatorClient{SharedServiceClient: shared.NewSharedServiceClientFactory(t, f)}
}

// Deprecated: Use NewCalculator instead
func NewCalculatorClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *CalculatorClient {
	return &CalculatorClient{SharedServiceClient: shared.NewSharedServiceClientProtocol(t, iprot, oprot)}
}

func NewCalculatorClient(c thrift.TClient) *CalculatorClient {
	return &CalculatorClient{
		c:                   c,
		SharedServiceClient: shared.NewSharedServiceClient(c),
	}
}

// A method definition looks like C code. It has a return type, arguments,
// and optionally a list of exceptions that it may throw. Note that argument
// lists and exception lists are specified using the exact same syntax as
// field lists in struct or exception definitions.
func (p *CalculatorClient) Ping(ctx context.Context) (err error) {
	var _args0 CalculatorPingArgs
	var _result1 CalculatorPingResult
	if err = p.c.Call(ctx, "ping", &_args0, &_result1); err != nil {
		return
	}
	return nil
}

// Parameters:
//  - Num1
//  - Num2
func (p *CalculatorClient) Add(ctx context.Context, num1 int32, num2 int32) (r int32, err error) {
	var _args2 CalculatorAddArgs
	_args2.Num1 = num1
	_args2.Num2 = num2
	var _result3 CalculatorAddResult
	if err = p.c.Call(ctx, "add", &_args2, &_result3); err != nil {
		return
	}
	return _result3.GetSuccess(), nil
}

// Parameters:
//  - Logid
//  - W
func (p *CalculatorClient) Calculate(ctx context.Context, logid int32, w *Work) (r int32, err error) {
	var _args4 CalculatorCalculateArgs
	_args4.Logid = logid
	_args4.W = w
	var _result5 CalculatorCalculateResult
	if err = p.c.Call(ctx, "calculate", &_args4, &_result5); err != nil {
		return
	}
	switch {
	case _result5.Ouch != nil:
		return r, _result5.Ouch
	}

	return _result5.GetSuccess(), nil
}

// This method has a oneway modifier. That means the client only makes
// a request and does not listen for any response at all. Oneway methods
// must be void.
func (p *CalculatorClient) Zip(ctx context.Context) (err error) {
	var _args6 CalculatorZipArgs
	if err := p.c.Call(ctx, "zip", &_args6, nil); err != nil {
		return err
	}
	return nil
}

type CalculatorProcessor struct {
	*shared.SharedServiceProcessor
}

func NewCalculatorProcessor(handler Calculator) *CalculatorProcessor {
	self7 := &CalculatorProcessor{shared.NewSharedServiceProcessor(handler)}
	self7.AddToProcessorMap("ping", &calculatorProcessorPing{handler: handler})
	self7.AddToProcessorMap("add", &calculatorProcessorAdd{handler: handler})
	self7.AddToProcessorMap("calculate", &calculatorProcessorCalculate{handler: handler})
	self7.AddToProcessorMap("zip", &calculatorProcessorZip{handler: handler})
	return self7
}

type calculatorProcessorPing struct {
	handler Calculator
}

func (p *calculatorProcessorPing) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := CalculatorPingArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("ping", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return false, err
	}

	iprot.ReadMessageEnd()
	result := CalculatorPingResult{}
	var err2 error
	if err2 = p.handler.Ping(ctx); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing ping: "+err2.Error())
		oprot.WriteMessageBegin("ping", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return true, err2
	}
	if err2 = oprot.WriteMessageBegin("ping", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type calculatorProcessorAdd struct {
	handler Calculator
}

func (p *calculatorProcessorAdd) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := CalculatorAddArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("add", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return false, err
	}

	iprot.ReadMessageEnd()
	result := CalculatorAddResult{}
	var retval int32
	var err2 error
	if retval, err2 = p.handler.Add(ctx, args.Num1, args.Num2); err2 != nil {
		x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing add: "+err2.Error())
		oprot.WriteMessageBegin("add", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return true, err2
	} else {
		result.Success = &retval
	}
	if err2 = oprot.WriteMessageBegin("add", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type calculatorProcessorCalculate struct {
	handler Calculator
}

func (p *calculatorProcessorCalculate) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := CalculatorCalculateArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("calculate", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return false, err
	}

	iprot.ReadMessageEnd()
	result := CalculatorCalculateResult{}
	var retval int32
	var err2 error
	if retval, err2 = p.handler.Calculate(ctx, args.Logid, args.W); err2 != nil {
		switch v := err2.(type) {
		case *InvalidOperation:
			result.Ouch = v
		default:
			x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing calculate: "+err2.Error())
			oprot.WriteMessageBegin("calculate", thrift.EXCEPTION, seqId)
			x.Write(oprot)
			oprot.WriteMessageEnd()
			oprot.Flush()
			return true, err2
		}
	} else {
		result.Success = &retval
	}
	if err2 = oprot.WriteMessageBegin("calculate", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type calculatorProcessorZip struct {
	handler Calculator
}

func (p *calculatorProcessorZip) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := CalculatorZipArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		return false, err
	}

	iprot.ReadMessageEnd()
	var err2 error
	if err2 = p.handler.Zip(ctx); err2 != nil {
		return true, err2
	}
	return true, nil
}

// HELPER FUNCTIONS AND STRUCTURES

type CalculatorPingArgs struct {
}

func NewCalculatorPingArgs() *CalculatorPingArgs {
	return &CalculatorPingArgs{}
}

func (p *CalculatorPingArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		if err := iprot.Skip(fieldTypeId); err != nil {
			return err
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

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

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

type CalculatorPingResult struct {
}

func NewCalculatorPingResult() *CalculatorPingResult {
	return &CalculatorPingResult{}
}

func (p *CalculatorPingResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		if err := iprot.Skip(fieldTypeId); err != nil {
			return err
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

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

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

// Attributes:
//  - Num1
//  - Num2
type CalculatorAddArgs struct {
	Num1 int32 `thrift:"num1,1" db:"num1" json:"num1"`
	Num2 int32 `thrift:"num2,2" db:"num2" json:"num2"`
}

func NewCalculatorAddArgs() *CalculatorAddArgs {
	return &CalculatorAddArgs{}
}

func (p *CalculatorAddArgs) GetNum1() int32 {
	return p.Num1
}

func (p *CalculatorAddArgs) GetNum2() int32 {
	return p.Num2
}
func (p *CalculatorAddArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *CalculatorAddArgs) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Num1 = v
	}
	return nil
}

func (p *CalculatorAddArgs) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.Num2 = v
	}
	return nil
}

func (p *CalculatorAddArgs) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("add_args"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *CalculatorAddArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("num1", thrift.I32, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:num1: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Num1)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.num1 (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:num1: ", p), err)
	}
	return err
}

func (p *CalculatorAddArgs) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("num2", thrift.I32, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:num2: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Num2)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.num2 (2) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:num2: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
type CalculatorAddResult struct {
	Success *int32 `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewCalculatorAddResult() *CalculatorAddResult {
	return &CalculatorAddResult{}
}

var CalculatorAddResult_Success_DEFAULT int32

func (p *CalculatorAddResult) GetSuccess() int32 {
	if !p.IsSetSuccess() {
		return CalculatorAddResult_Success_DEFAULT
	}
	return *p.Success
}
func (p *CalculatorAddResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *CalculatorAddResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *CalculatorAddResult) ReadField0(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 0: ", err)
	} else {
		p.Success = &v
	}
	return nil
}

func (p *CalculatorAddResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("add_result"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		if err := p.writeField0(oprot); err != nil {
			return err
		}
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *CalculatorAddResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.I32, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.Success)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Logid
//  - W
type CalculatorCalculateArgs struct {
	Logid int32 `thrift:"logid,1" db:"logid" json:"logid"`
	W     *Work `thrift:"w,2" db:"w" json:"w"`
}

func NewCalculatorCalculateArgs() *CalculatorCalculateArgs {
	return &CalculatorCalculateArgs{}
}

func (p *CalculatorCalculateArgs) GetLogid() int32 {
	return p.Logid
}

var CalculatorCalculateArgs_W_DEFAULT *Work

func (p *CalculatorCalculateArgs) GetW() *Work {
	if !p.IsSetW() {
		return CalculatorCalculateArgs_W_DEFAULT
	}
	return p.W
}
func (p *CalculatorCalculateArgs) IsSetW() bool {
	return p.W != nil
}

func (p *CalculatorCalculateArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *CalculatorCalculateArgs) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Logid = v
	}
	return nil
}

func (p *CalculatorCalculateArgs) ReadField2(iprot thrift.TProtocol) error {
	p.W = &Work{}
	if err := p.W.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.W), err)
	}
	return nil
}

func (p *CalculatorCalculateArgs) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("calculate_args"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if p != nil {
		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 thrift.PrependError("write field stop error: ", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return thrift.PrependError("write struct stop error: ", err)
	}
	return nil
}

func (p *CalculatorCalculateArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("logid", thrift.I32, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:logid: ", p), err)
	}
	if err := oprot.WriteI32(int32(p.Logid)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.logid (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:logid: ", p), err)
	}
	return err
}

func (p *CalculatorCalculateArgs) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("w", thrift.STRUCT, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:w: ", p), err)
	}
	if err := p.W.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.W), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:w: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Success
//  - Ouch
type CalculatorCalculateResult struct {
	Success *int32            `thrift:"success,0" db:"success" json:"success,omitempty"`
	Ouch    *InvalidOperation `thrift:"ouch,1" db:"ouch" json:"ouch,omitempty"`
}

func NewCalculatorCalculateResult() *CalculatorCalculateResult {
	return &CalculatorCalculateResult{}
}

var CalculatorCalculateResult_Success_DEFAULT int32

func (p *CalculatorCalculateResult) GetSuccess() int32 {
	if !p.IsSetSuccess() {
		return CalculatorCalculateResult_Success_DEFAULT
	}
	return *p.Success
}

var CalculatorCalculateResult_Ouch_DEFAULT *InvalidOperation

func (p *CalculatorCalculateResult) GetOuch() *InvalidOperation {
	if !p.IsSetOuch() {
		return CalculatorCalculateResult_Ouch_DEFAULT
	}
	return p.Ouch
}
func (p *CalculatorCalculateResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *CalculatorCalculateResult) IsSetOuch() bool {
	return p.Ouch != nil
}

func (p *CalculatorCalculateResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField0(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 1:
			if fieldTypeId == thrift.STRUCT {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); 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 thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *CalculatorCalculateResult) ReadField0(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 0: ", err)
	} else {
		p.Success = &v
	}
	return nil
}

func (p *CalculatorCalculateResult) ReadField1(iprot thrift.TProtocol) error {
	p.Ouch = &InvalidOperation{}
	if err := p.Ouch.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ouch), err)
	}
	return nil
}

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

func (p *CalculatorCalculateResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.I32, 0); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.Success)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err)
		}
	}
	return err
}

func (p *CalculatorCalculateResult) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetOuch() {
		if err := oprot.WriteFieldBegin("ouch", thrift.STRUCT, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ouch: ", p), err)
		}
		if err := p.Ouch.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Ouch), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ouch: ", p), err)
		}
	}
	return err
}

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

type CalculatorZipArgs struct {
}

func NewCalculatorZipArgs() *CalculatorZipArgs {
	return &CalculatorZipArgs{}
}

func (p *CalculatorZipArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		if err := iprot.Skip(fieldTypeId); err != nil {
			return err
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

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

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