// @generated by Thrift for [[[ program path ]]]
// This file is probably not the place you want to edit!

package module // [[[ program thrift source path ]]]


import (
    "context"
    "fmt"
    "strings"
    "sync"

    thrift "github.com/facebook/fbthrift/thrift/lib/go/thrift"
    metadata "github.com/facebook/fbthrift/thrift/lib/thrift/metadata"
)

// (needed to ensure safety because of naive import list construction)
var _ = context.Background
var _ = fmt.Printf
var _ = strings.Split
var _ = sync.Mutex{}
var _ = thrift.ZERO
var _ = metadata.GoUnusedProtection__



type FooService interface {
    SimpleRPC(ctx context.Context) (error)
}

type FooServiceChannelClientInterface interface {
    thrift.ClientInterface
    FooService
}

type FooServiceClientInterface interface {
    thrift.ClientInterface
    SimpleRPC() (error)
}

type FooServiceContextClientInterface interface {
    FooServiceClientInterface
    SimpleRPCContext(ctx context.Context) (error)
}

type FooServiceChannelClient struct {
    ch thrift.RequestChannel
}
// Compile time interface enforcer
var _ FooServiceChannelClientInterface = &FooServiceChannelClient{}

func NewFooServiceChannelClient(channel thrift.RequestChannel) *FooServiceChannelClient {
    return &FooServiceChannelClient{
        ch: channel,
    }
}

func (c *FooServiceChannelClient) Close() error {
    return c.ch.Close()
}

type FooServiceClient struct {
    chClient *FooServiceChannelClient
    Mu       sync.Mutex
}
// Compile time interface enforcer
var _ FooServiceClientInterface = &FooServiceClient{}
var _ FooServiceContextClientInterface = &FooServiceClient{}

func NewFooServiceClient(prot thrift.Protocol) *FooServiceClient {
    return &FooServiceClient{
        chClient: NewFooServiceChannelClient(
            thrift.NewSerialChannel(prot),
        ),
    }
}

func (c *FooServiceClient) Close() error {
    return c.chClient.Close()
}

func (c *FooServiceChannelClient) SimpleRPC(ctx context.Context) (error) {
    in := &reqFooServiceSimpleRPC{
    }
    out := newRespFooServiceSimpleRPC()
    err := c.ch.Call(ctx, "simple_rpc", in, out)
    if err != nil {
        return err
    }
    return nil
}

func (c *FooServiceClient) SimpleRPC() (error) {
    return c.chClient.SimpleRPC(context.Background())
}

func (c *FooServiceClient) SimpleRPCContext(ctx context.Context) (error) {
    return c.chClient.SimpleRPC(ctx)
}

type reqFooServiceSimpleRPC struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &reqFooServiceSimpleRPC{}

// Deprecated: FooServiceSimpleRPCArgsDeprecated is deprecated, since it is supposed to be internal.
type FooServiceSimpleRPCArgsDeprecated = reqFooServiceSimpleRPC

func newReqFooServiceSimpleRPC() *reqFooServiceSimpleRPC {
    return (&reqFooServiceSimpleRPC{})
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqFooServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqFooServiceSimpleRPCBuilder struct {
    obj *reqFooServiceSimpleRPC
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqFooServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqFooServiceSimpleRPCBuilder() *reqFooServiceSimpleRPCBuilder {
    return &reqFooServiceSimpleRPCBuilder{
        obj: newReqFooServiceSimpleRPC(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqFooServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqFooServiceSimpleRPCBuilder) Emit() *reqFooServiceSimpleRPC {
    var objCopy reqFooServiceSimpleRPC = *x.obj
    return &objCopy
}

func (x *reqFooServiceSimpleRPC) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqFooServiceSimpleRPC"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqFooServiceSimpleRPC) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqFooServiceSimpleRPC({")
    sb.WriteString("})")

    return sb.String()
}
type respFooServiceSimpleRPC struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &respFooServiceSimpleRPC{}
var _ thrift.WritableResult = &respFooServiceSimpleRPC{}

// Deprecated: FooServiceSimpleRPCResultDeprecated is deprecated, since it is supposed to be internal.
type FooServiceSimpleRPCResultDeprecated = respFooServiceSimpleRPC

func newRespFooServiceSimpleRPC() *respFooServiceSimpleRPC {
    return (&respFooServiceSimpleRPC{})
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespFooServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
type respFooServiceSimpleRPCBuilder struct {
    obj *respFooServiceSimpleRPC
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespFooServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespFooServiceSimpleRPCBuilder() *respFooServiceSimpleRPCBuilder {
    return &respFooServiceSimpleRPCBuilder{
        obj: newRespFooServiceSimpleRPC(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespFooServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respFooServiceSimpleRPCBuilder) Emit() *respFooServiceSimpleRPC {
    var objCopy respFooServiceSimpleRPC = *x.obj
    return &objCopy
}

func (x *respFooServiceSimpleRPC) Exception() thrift.WritableException {
    return nil
}

func (x *respFooServiceSimpleRPC) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respFooServiceSimpleRPC"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respFooServiceSimpleRPC) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respFooServiceSimpleRPC({")
    sb.WriteString("})")

    return sb.String()
}


type FooServiceProcessor struct {
    processorMap       map[string]thrift.ProcessorFunctionContext
    functionServiceMap map[string]string
    handler            FooService
}
// Compile time interface enforcer
var _ thrift.ProcessorContext = &FooServiceProcessor{}

func NewFooServiceProcessor(handler FooService) *FooServiceProcessor {
    p := &FooServiceProcessor{
        handler:            handler,
        processorMap:       make(map[string]thrift.ProcessorFunctionContext),
        functionServiceMap: make(map[string]string),
    }
    p.AddToProcessorMap("simple_rpc", &procFuncFooServiceSimpleRPC{handler: handler})
    p.AddToFunctionServiceMap("simple_rpc", "FooService")

    return p
}

func (p *FooServiceProcessor) AddToProcessorMap(key string, processor thrift.ProcessorFunctionContext) {
    p.processorMap[key] = processor
}

func (p *FooServiceProcessor) AddToFunctionServiceMap(key, service string) {
    p.functionServiceMap[key] = service
}

func (p *FooServiceProcessor) GetProcessorFunctionContext(key string) (processor thrift.ProcessorFunctionContext, err error) {
    if processor, ok := p.processorMap[key]; ok {
        return processor, nil
    }
    return nil, nil
}

func (p *FooServiceProcessor) ProcessorMap() map[string]thrift.ProcessorFunctionContext {
    return p.processorMap
}

func (p *FooServiceProcessor) FunctionServiceMap() map[string]string {
    return p.functionServiceMap
}

func (p *FooServiceProcessor) GetThriftMetadata() *metadata.ThriftMetadata {
    return GetThriftMetadataForService("module.FooService")
}


type procFuncFooServiceSimpleRPC struct {
    handler FooService
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncFooServiceSimpleRPC{}

func (p *procFuncFooServiceSimpleRPC) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqFooServiceSimpleRPC()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncFooServiceSimpleRPC) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("simple_rpc", messageType, 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
    }
    return err
}

func (p *procFuncFooServiceSimpleRPC) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    result := newRespFooServiceSimpleRPC()
    err := p.handler.SimpleRPC(ctx)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing SimpleRPC: " + err.Error(), err)
        return x, x
    }

    return result, nil
}




type FB303Service interface {
    SimpleRPC(ctx context.Context, intParameter int32) (*ReservedKeyword, error)
}

type FB303ServiceChannelClientInterface interface {
    thrift.ClientInterface
    FB303Service
}

type FB303ServiceClientInterface interface {
    thrift.ClientInterface
    SimpleRPC(intParameter int32) (*ReservedKeyword, error)
}

type FB303ServiceContextClientInterface interface {
    FB303ServiceClientInterface
    SimpleRPCContext(ctx context.Context, intParameter int32) (*ReservedKeyword, error)
}

type FB303ServiceChannelClient struct {
    ch thrift.RequestChannel
}
// Compile time interface enforcer
var _ FB303ServiceChannelClientInterface = &FB303ServiceChannelClient{}

func NewFB303ServiceChannelClient(channel thrift.RequestChannel) *FB303ServiceChannelClient {
    return &FB303ServiceChannelClient{
        ch: channel,
    }
}

func (c *FB303ServiceChannelClient) Close() error {
    return c.ch.Close()
}

type FB303ServiceClient struct {
    chClient *FB303ServiceChannelClient
    Mu       sync.Mutex
}
// Compile time interface enforcer
var _ FB303ServiceClientInterface = &FB303ServiceClient{}
var _ FB303ServiceContextClientInterface = &FB303ServiceClient{}

func NewFB303ServiceClient(prot thrift.Protocol) *FB303ServiceClient {
    return &FB303ServiceClient{
        chClient: NewFB303ServiceChannelClient(
            thrift.NewSerialChannel(prot),
        ),
    }
}

func (c *FB303ServiceClient) Close() error {
    return c.chClient.Close()
}

func (c *FB303ServiceChannelClient) SimpleRPC(ctx context.Context, intParameter int32) (*ReservedKeyword, error) {
    in := &reqFB303ServiceSimpleRPC{
        IntParameter: intParameter,
    }
    out := newRespFB303ServiceSimpleRPC()
    err := c.ch.Call(ctx, "simple_rpc", in, out)
    if err != nil {
        return nil, err
    }
    return out.GetSuccess(), nil
}

func (c *FB303ServiceClient) SimpleRPC(intParameter int32) (*ReservedKeyword, error) {
    return c.chClient.SimpleRPC(context.Background(), intParameter)
}

func (c *FB303ServiceClient) SimpleRPCContext(ctx context.Context, intParameter int32) (*ReservedKeyword, error) {
    return c.chClient.SimpleRPC(ctx, intParameter)
}

type reqFB303ServiceSimpleRPC struct {
    IntParameter int32 `thrift:"int_parameter,1" json:"int_parameter" db:"int_parameter"`
}
// Compile time interface enforcer
var _ thrift.Struct = &reqFB303ServiceSimpleRPC{}

// Deprecated: FB303ServiceSimpleRPCArgsDeprecated is deprecated, since it is supposed to be internal.
type FB303ServiceSimpleRPCArgsDeprecated = reqFB303ServiceSimpleRPC

func newReqFB303ServiceSimpleRPC() *reqFB303ServiceSimpleRPC {
    return (&reqFB303ServiceSimpleRPC{}).
        SetIntParameterNonCompat(0)
}

func (x *reqFB303ServiceSimpleRPC) GetIntParameterNonCompat() int32 {
    return x.IntParameter
}

func (x *reqFB303ServiceSimpleRPC) GetIntParameter() int32 {
    return x.IntParameter
}

func (x *reqFB303ServiceSimpleRPC) SetIntParameterNonCompat(value int32) *reqFB303ServiceSimpleRPC {
    x.IntParameter = value
    return x
}

func (x *reqFB303ServiceSimpleRPC) SetIntParameter(value int32) *reqFB303ServiceSimpleRPC {
    x.IntParameter = value
    return x
}

func (x *reqFB303ServiceSimpleRPC) writeField1(p thrift.Format) error {  // IntParameter
    if err := p.WriteFieldBegin("int_parameter", thrift.I32, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetIntParameterNonCompat()
    if err := p.WriteI32(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *reqFB303ServiceSimpleRPC) readField1(p thrift.Format) error {  // IntParameter
    result, err := p.ReadI32()
if err != nil {
    return err
}

    x.SetIntParameterNonCompat(result)
    return nil
}

func (x *reqFB303ServiceSimpleRPC) toString1() string {  // IntParameter
    return fmt.Sprintf("%v", x.GetIntParameterNonCompat())
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqFB303ServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqFB303ServiceSimpleRPCBuilder struct {
    obj *reqFB303ServiceSimpleRPC
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqFB303ServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqFB303ServiceSimpleRPCBuilder() *reqFB303ServiceSimpleRPCBuilder {
    return &reqFB303ServiceSimpleRPCBuilder{
        obj: newReqFB303ServiceSimpleRPC(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqFB303ServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqFB303ServiceSimpleRPCBuilder) IntParameter(value int32) *reqFB303ServiceSimpleRPCBuilder {
    x.obj.IntParameter = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqFB303ServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqFB303ServiceSimpleRPCBuilder) Emit() *reqFB303ServiceSimpleRPC {
    var objCopy reqFB303ServiceSimpleRPC = *x.obj
    return &objCopy
}

func (x *reqFB303ServiceSimpleRPC) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqFB303ServiceSimpleRPC"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 1 && wireType == thrift.Type(thrift.I32)):  // int_parameter
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqFB303ServiceSimpleRPC) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqFB303ServiceSimpleRPC({")
    sb.WriteString(fmt.Sprintf("IntParameter:%s", x.toString1()))
    sb.WriteString("})")

    return sb.String()
}
type respFB303ServiceSimpleRPC struct {
    Success *ReservedKeyword `thrift:"success,0,optional" json:"success,omitempty" db:"success"`
}
// Compile time interface enforcer
var _ thrift.Struct = &respFB303ServiceSimpleRPC{}
var _ thrift.WritableResult = &respFB303ServiceSimpleRPC{}

// Deprecated: FB303ServiceSimpleRPCResultDeprecated is deprecated, since it is supposed to be internal.
type FB303ServiceSimpleRPCResultDeprecated = respFB303ServiceSimpleRPC

func newRespFB303ServiceSimpleRPC() *respFB303ServiceSimpleRPC {
    return (&respFB303ServiceSimpleRPC{})
}

func (x *respFB303ServiceSimpleRPC) GetSuccessNonCompat() *ReservedKeyword {
    return x.Success
}

func (x *respFB303ServiceSimpleRPC) GetSuccess() *ReservedKeyword {
    if !x.IsSetSuccess() {
        return nil
    }

    return x.Success
}

func (x *respFB303ServiceSimpleRPC) SetSuccessNonCompat(value ReservedKeyword) *respFB303ServiceSimpleRPC {
    x.Success = &value
    return x
}

func (x *respFB303ServiceSimpleRPC) SetSuccess(value *ReservedKeyword) *respFB303ServiceSimpleRPC {
    x.Success = value
    return x
}

func (x *respFB303ServiceSimpleRPC) IsSetSuccess() bool {
    return x != nil && x.Success != nil
}

func (x *respFB303ServiceSimpleRPC) writeField0(p thrift.Format) error {  // Success
    if !x.IsSetSuccess() {
        return nil
    }

    if err := p.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetSuccessNonCompat()
    if err := item.Write(p); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *respFB303ServiceSimpleRPC) readField0(p thrift.Format) error {  // Success
    result := *NewReservedKeyword()
err := result.Read(p)
if err != nil {
    return err
}

    x.SetSuccessNonCompat(result)
    return nil
}

func (x *respFB303ServiceSimpleRPC) toString0() string {  // Success
    return fmt.Sprintf("%v", x.GetSuccessNonCompat())
}

// Deprecated: Use newRespFB303ServiceSimpleRPC().GetSuccess() instead.
func (x *respFB303ServiceSimpleRPC) DefaultGetSuccess() *ReservedKeyword {
    if !x.IsSetSuccess() {
        return NewReservedKeyword()
    }
    return x.Success
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespFB303ServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
type respFB303ServiceSimpleRPCBuilder struct {
    obj *respFB303ServiceSimpleRPC
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespFB303ServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespFB303ServiceSimpleRPCBuilder() *respFB303ServiceSimpleRPCBuilder {
    return &respFB303ServiceSimpleRPCBuilder{
        obj: newRespFB303ServiceSimpleRPC(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespFB303ServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respFB303ServiceSimpleRPCBuilder) Success(value *ReservedKeyword) *respFB303ServiceSimpleRPCBuilder {
    x.obj.Success = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespFB303ServiceSimpleRPC().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respFB303ServiceSimpleRPCBuilder) Emit() *respFB303ServiceSimpleRPC {
    var objCopy respFB303ServiceSimpleRPC = *x.obj
    return &objCopy
}

func (x *respFB303ServiceSimpleRPC) Exception() thrift.WritableException {
    return nil
}

func (x *respFB303ServiceSimpleRPC) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respFB303ServiceSimpleRPC"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField0(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 0 && wireType == thrift.Type(thrift.STRUCT)):  // success
            if err := x.readField0(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respFB303ServiceSimpleRPC) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respFB303ServiceSimpleRPC({")
    sb.WriteString(fmt.Sprintf("Success:%s", x.toString0()))
    sb.WriteString("})")

    return sb.String()
}


type FB303ServiceProcessor struct {
    processorMap       map[string]thrift.ProcessorFunctionContext
    functionServiceMap map[string]string
    handler            FB303Service
}
// Compile time interface enforcer
var _ thrift.ProcessorContext = &FB303ServiceProcessor{}

func NewFB303ServiceProcessor(handler FB303Service) *FB303ServiceProcessor {
    p := &FB303ServiceProcessor{
        handler:            handler,
        processorMap:       make(map[string]thrift.ProcessorFunctionContext),
        functionServiceMap: make(map[string]string),
    }
    p.AddToProcessorMap("simple_rpc", &procFuncFB303ServiceSimpleRPC{handler: handler})
    p.AddToFunctionServiceMap("simple_rpc", "FB303Service")

    return p
}

func (p *FB303ServiceProcessor) AddToProcessorMap(key string, processor thrift.ProcessorFunctionContext) {
    p.processorMap[key] = processor
}

func (p *FB303ServiceProcessor) AddToFunctionServiceMap(key, service string) {
    p.functionServiceMap[key] = service
}

func (p *FB303ServiceProcessor) GetProcessorFunctionContext(key string) (processor thrift.ProcessorFunctionContext, err error) {
    if processor, ok := p.processorMap[key]; ok {
        return processor, nil
    }
    return nil, nil
}

func (p *FB303ServiceProcessor) ProcessorMap() map[string]thrift.ProcessorFunctionContext {
    return p.processorMap
}

func (p *FB303ServiceProcessor) FunctionServiceMap() map[string]string {
    return p.functionServiceMap
}

func (p *FB303ServiceProcessor) GetThriftMetadata() *metadata.ThriftMetadata {
    return GetThriftMetadataForService("module.FB303Service")
}


type procFuncFB303ServiceSimpleRPC struct {
    handler FB303Service
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncFB303ServiceSimpleRPC{}

func (p *procFuncFB303ServiceSimpleRPC) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqFB303ServiceSimpleRPC()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncFB303ServiceSimpleRPC) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("simple_rpc", messageType, 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
    }
    return err
}

func (p *procFuncFB303ServiceSimpleRPC) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    args := reqStruct.(*reqFB303ServiceSimpleRPC)
    result := newRespFB303ServiceSimpleRPC()
    retval, err := p.handler.SimpleRPC(ctx, args.IntParameter)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing SimpleRPC: " + err.Error(), err)
        return x, x
    }

    result.Success = retval
    return result, nil
}




type MyService interface {
    Ping(ctx context.Context) (error)
    GetRandomData(ctx context.Context) (string, error)
    Sink(ctx context.Context, sink int64) (error)
    PutDataById(ctx context.Context, id int64, data string) (error)
    HasDataById(ctx context.Context, id int64) (bool, error)
    GetDataById(ctx context.Context, id int64) (string, error)
    DeleteDataById(ctx context.Context, id int64) (error)
    LobDataById(ctx context.Context, id int64, data string) (error)
    InvalidReturnForHack(ctx context.Context) ([]float32, error)
    RpcSkippedCodegen(ctx context.Context) (error)
}

type MyServiceChannelClientInterface interface {
    thrift.ClientInterface
    MyService
}

type MyServiceClientInterface interface {
    thrift.ClientInterface
    Ping() (error)
    GetRandomData() (string, error)
    Sink(sink int64) (error)
    PutDataById(id int64, data string) (error)
    HasDataById(id int64) (bool, error)
    GetDataById(id int64) (string, error)
    DeleteDataById(id int64) (error)
    LobDataById(id int64, data string) (error)
    InvalidReturnForHack() ([]float32, error)
    RpcSkippedCodegen() (error)
}

type MyServiceContextClientInterface interface {
    MyServiceClientInterface
    PingContext(ctx context.Context) (error)
    GetRandomDataContext(ctx context.Context) (string, error)
    SinkContext(ctx context.Context, sink int64) (error)
    PutDataByIdContext(ctx context.Context, id int64, data string) (error)
    HasDataByIdContext(ctx context.Context, id int64) (bool, error)
    GetDataByIdContext(ctx context.Context, id int64) (string, error)
    DeleteDataByIdContext(ctx context.Context, id int64) (error)
    LobDataByIdContext(ctx context.Context, id int64, data string) (error)
    InvalidReturnForHackContext(ctx context.Context) ([]float32, error)
    RpcSkippedCodegenContext(ctx context.Context) (error)
}

type MyServiceChannelClient struct {
    ch thrift.RequestChannel
}
// Compile time interface enforcer
var _ MyServiceChannelClientInterface = &MyServiceChannelClient{}

func NewMyServiceChannelClient(channel thrift.RequestChannel) *MyServiceChannelClient {
    return &MyServiceChannelClient{
        ch: channel,
    }
}

func (c *MyServiceChannelClient) Close() error {
    return c.ch.Close()
}

type MyServiceClient struct {
    chClient *MyServiceChannelClient
    Mu       sync.Mutex
}
// Compile time interface enforcer
var _ MyServiceClientInterface = &MyServiceClient{}
var _ MyServiceContextClientInterface = &MyServiceClient{}

func NewMyServiceClient(prot thrift.Protocol) *MyServiceClient {
    return &MyServiceClient{
        chClient: NewMyServiceChannelClient(
            thrift.NewSerialChannel(prot),
        ),
    }
}

func (c *MyServiceClient) Close() error {
    return c.chClient.Close()
}

func (c *MyServiceChannelClient) Ping(ctx context.Context) (error) {
    in := &reqMyServicePing{
    }
    out := newRespMyServicePing()
    err := c.ch.Call(ctx, "ping", in, out)
    if err != nil {
        return err
    }
    return nil
}

func (c *MyServiceClient) Ping() (error) {
    return c.chClient.Ping(context.Background())
}

func (c *MyServiceClient) PingContext(ctx context.Context) (error) {
    return c.chClient.Ping(ctx)
}

func (c *MyServiceChannelClient) GetRandomData(ctx context.Context) (string, error) {
    in := &reqMyServiceGetRandomData{
    }
    out := newRespMyServiceGetRandomData()
    err := c.ch.Call(ctx, "getRandomData", in, out)
    if err != nil {
        return "", err
    }
    return out.GetSuccess(), nil
}

func (c *MyServiceClient) GetRandomData() (string, error) {
    return c.chClient.GetRandomData(context.Background())
}

func (c *MyServiceClient) GetRandomDataContext(ctx context.Context) (string, error) {
    return c.chClient.GetRandomData(ctx)
}

func (c *MyServiceChannelClient) Sink(ctx context.Context, sink int64) (error) {
    in := &reqMyServiceSink{
        Sink: sink,
    }
    out := newRespMyServiceSink()
    err := c.ch.Call(ctx, "sink", in, out)
    if err != nil {
        return err
    }
    return nil
}

func (c *MyServiceClient) Sink(sink int64) (error) {
    return c.chClient.Sink(context.Background(), sink)
}

func (c *MyServiceClient) SinkContext(ctx context.Context, sink int64) (error) {
    return c.chClient.Sink(ctx, sink)
}

func (c *MyServiceChannelClient) PutDataById(ctx context.Context, id int64, data string) (error) {
    in := &reqMyServicePutDataById{
        Id: id,
        Data: data,
    }
    out := newRespMyServicePutDataById()
    err := c.ch.Call(ctx, "putDataById", in, out)
    if err != nil {
        return err
    }
    return nil
}

func (c *MyServiceClient) PutDataById(id int64, data string) (error) {
    return c.chClient.PutDataById(context.Background(), id, data)
}

func (c *MyServiceClient) PutDataByIdContext(ctx context.Context, id int64, data string) (error) {
    return c.chClient.PutDataById(ctx, id, data)
}

func (c *MyServiceChannelClient) HasDataById(ctx context.Context, id int64) (bool, error) {
    in := &reqMyServiceHasDataById{
        Id: id,
    }
    out := newRespMyServiceHasDataById()
    err := c.ch.Call(ctx, "hasDataById", in, out)
    if err != nil {
        return false, err
    }
    return out.GetSuccess(), nil
}

func (c *MyServiceClient) HasDataById(id int64) (bool, error) {
    return c.chClient.HasDataById(context.Background(), id)
}

func (c *MyServiceClient) HasDataByIdContext(ctx context.Context, id int64) (bool, error) {
    return c.chClient.HasDataById(ctx, id)
}

func (c *MyServiceChannelClient) GetDataById(ctx context.Context, id int64) (string, error) {
    in := &reqMyServiceGetDataById{
        Id: id,
    }
    out := newRespMyServiceGetDataById()
    err := c.ch.Call(ctx, "getDataById", in, out)
    if err != nil {
        return "", err
    }
    return out.GetSuccess(), nil
}

func (c *MyServiceClient) GetDataById(id int64) (string, error) {
    return c.chClient.GetDataById(context.Background(), id)
}

func (c *MyServiceClient) GetDataByIdContext(ctx context.Context, id int64) (string, error) {
    return c.chClient.GetDataById(ctx, id)
}

func (c *MyServiceChannelClient) DeleteDataById(ctx context.Context, id int64) (error) {
    in := &reqMyServiceDeleteDataById{
        Id: id,
    }
    out := newRespMyServiceDeleteDataById()
    err := c.ch.Call(ctx, "deleteDataById", in, out)
    if err != nil {
        return err
    }
    return nil
}

func (c *MyServiceClient) DeleteDataById(id int64) (error) {
    return c.chClient.DeleteDataById(context.Background(), id)
}

func (c *MyServiceClient) DeleteDataByIdContext(ctx context.Context, id int64) (error) {
    return c.chClient.DeleteDataById(ctx, id)
}

func (c *MyServiceChannelClient) LobDataById(ctx context.Context, id int64, data string) (error) {
    in := &reqMyServiceLobDataById{
        Id: id,
        Data: data,
    }
    return c.ch.Oneway(ctx, "lobDataById", in)
}

func (c *MyServiceClient) LobDataById(id int64, data string) (error) {
    return c.chClient.LobDataById(context.Background(), id, data)
}

func (c *MyServiceClient) LobDataByIdContext(ctx context.Context, id int64, data string) (error) {
    return c.chClient.LobDataById(ctx, id, data)
}

func (c *MyServiceChannelClient) InvalidReturnForHack(ctx context.Context) ([]float32, error) {
    in := &reqMyServiceInvalidReturnForHack{
    }
    out := newRespMyServiceInvalidReturnForHack()
    err := c.ch.Call(ctx, "invalid_return_for_hack", in, out)
    if err != nil {
        return nil, err
    }
    return out.GetSuccess(), nil
}

func (c *MyServiceClient) InvalidReturnForHack() ([]float32, error) {
    return c.chClient.InvalidReturnForHack(context.Background())
}

func (c *MyServiceClient) InvalidReturnForHackContext(ctx context.Context) ([]float32, error) {
    return c.chClient.InvalidReturnForHack(ctx)
}

func (c *MyServiceChannelClient) RpcSkippedCodegen(ctx context.Context) (error) {
    in := &reqMyServiceRpcSkippedCodegen{
    }
    out := newRespMyServiceRpcSkippedCodegen()
    err := c.ch.Call(ctx, "rpc_skipped_codegen", in, out)
    if err != nil {
        return err
    }
    return nil
}

func (c *MyServiceClient) RpcSkippedCodegen() (error) {
    return c.chClient.RpcSkippedCodegen(context.Background())
}

func (c *MyServiceClient) RpcSkippedCodegenContext(ctx context.Context) (error) {
    return c.chClient.RpcSkippedCodegen(ctx)
}

type reqMyServicePing struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &reqMyServicePing{}

// Deprecated: MyServicePingArgsDeprecated is deprecated, since it is supposed to be internal.
type MyServicePingArgsDeprecated = reqMyServicePing

func newReqMyServicePing() *reqMyServicePing {
    return (&reqMyServicePing{})
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServicePing().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqMyServicePingBuilder struct {
    obj *reqMyServicePing
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServicePing().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqMyServicePingBuilder() *reqMyServicePingBuilder {
    return &reqMyServicePingBuilder{
        obj: newReqMyServicePing(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServicePing().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServicePingBuilder) Emit() *reqMyServicePing {
    var objCopy reqMyServicePing = *x.obj
    return &objCopy
}

func (x *reqMyServicePing) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqMyServicePing"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqMyServicePing) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqMyServicePing({")
    sb.WriteString("})")

    return sb.String()
}
type respMyServicePing struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &respMyServicePing{}
var _ thrift.WritableResult = &respMyServicePing{}

// Deprecated: MyServicePingResultDeprecated is deprecated, since it is supposed to be internal.
type MyServicePingResultDeprecated = respMyServicePing

func newRespMyServicePing() *respMyServicePing {
    return (&respMyServicePing{})
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServicePing().Set<FieldNameFoo>().Set<FieldNameBar>()
type respMyServicePingBuilder struct {
    obj *respMyServicePing
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServicePing().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespMyServicePingBuilder() *respMyServicePingBuilder {
    return &respMyServicePingBuilder{
        obj: newRespMyServicePing(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServicePing().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServicePingBuilder) Emit() *respMyServicePing {
    var objCopy respMyServicePing = *x.obj
    return &objCopy
}

func (x *respMyServicePing) Exception() thrift.WritableException {
    return nil
}

func (x *respMyServicePing) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respMyServicePing"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respMyServicePing) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respMyServicePing({")
    sb.WriteString("})")

    return sb.String()
}
type reqMyServiceGetRandomData struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &reqMyServiceGetRandomData{}

// Deprecated: MyServiceGetRandomDataArgsDeprecated is deprecated, since it is supposed to be internal.
type MyServiceGetRandomDataArgsDeprecated = reqMyServiceGetRandomData

func newReqMyServiceGetRandomData() *reqMyServiceGetRandomData {
    return (&reqMyServiceGetRandomData{})
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceGetRandomData().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqMyServiceGetRandomDataBuilder struct {
    obj *reqMyServiceGetRandomData
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceGetRandomData().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqMyServiceGetRandomDataBuilder() *reqMyServiceGetRandomDataBuilder {
    return &reqMyServiceGetRandomDataBuilder{
        obj: newReqMyServiceGetRandomData(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceGetRandomData().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceGetRandomDataBuilder) Emit() *reqMyServiceGetRandomData {
    var objCopy reqMyServiceGetRandomData = *x.obj
    return &objCopy
}

func (x *reqMyServiceGetRandomData) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqMyServiceGetRandomData"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqMyServiceGetRandomData) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqMyServiceGetRandomData({")
    sb.WriteString("})")

    return sb.String()
}
type respMyServiceGetRandomData struct {
    Success *string `thrift:"success,0,optional" json:"success,omitempty" db:"success"`
}
// Compile time interface enforcer
var _ thrift.Struct = &respMyServiceGetRandomData{}
var _ thrift.WritableResult = &respMyServiceGetRandomData{}

// Deprecated: MyServiceGetRandomDataResultDeprecated is deprecated, since it is supposed to be internal.
type MyServiceGetRandomDataResultDeprecated = respMyServiceGetRandomData

func newRespMyServiceGetRandomData() *respMyServiceGetRandomData {
    return (&respMyServiceGetRandomData{})
}

func (x *respMyServiceGetRandomData) GetSuccessNonCompat() *string {
    return x.Success
}

func (x *respMyServiceGetRandomData) GetSuccess() string {
    if !x.IsSetSuccess() {
        return ""
    }

    return *x.Success
}

func (x *respMyServiceGetRandomData) SetSuccessNonCompat(value string) *respMyServiceGetRandomData {
    x.Success = &value
    return x
}

func (x *respMyServiceGetRandomData) SetSuccess(value *string) *respMyServiceGetRandomData {
    x.Success = value
    return x
}

func (x *respMyServiceGetRandomData) IsSetSuccess() bool {
    return x != nil && x.Success != nil
}

func (x *respMyServiceGetRandomData) writeField0(p thrift.Format) error {  // Success
    if !x.IsSetSuccess() {
        return nil
    }

    if err := p.WriteFieldBegin("success", thrift.STRING, 0); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := *x.GetSuccessNonCompat()
    if err := p.WriteString(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *respMyServiceGetRandomData) readField0(p thrift.Format) error {  // Success
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetSuccessNonCompat(result)
    return nil
}

func (x *respMyServiceGetRandomData) toString0() string {  // Success
    if x.IsSetSuccess() {
        return fmt.Sprintf("%v", *x.GetSuccessNonCompat())
    }
    return fmt.Sprintf("%v", x.GetSuccessNonCompat())
}



// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceGetRandomData().Set<FieldNameFoo>().Set<FieldNameBar>()
type respMyServiceGetRandomDataBuilder struct {
    obj *respMyServiceGetRandomData
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceGetRandomData().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespMyServiceGetRandomDataBuilder() *respMyServiceGetRandomDataBuilder {
    return &respMyServiceGetRandomDataBuilder{
        obj: newRespMyServiceGetRandomData(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceGetRandomData().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServiceGetRandomDataBuilder) Success(value *string) *respMyServiceGetRandomDataBuilder {
    x.obj.Success = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceGetRandomData().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServiceGetRandomDataBuilder) Emit() *respMyServiceGetRandomData {
    var objCopy respMyServiceGetRandomData = *x.obj
    return &objCopy
}

func (x *respMyServiceGetRandomData) Exception() thrift.WritableException {
    return nil
}

func (x *respMyServiceGetRandomData) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respMyServiceGetRandomData"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField0(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 0 && wireType == thrift.Type(thrift.STRING)):  // success
            if err := x.readField0(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respMyServiceGetRandomData) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respMyServiceGetRandomData({")
    sb.WriteString(fmt.Sprintf("Success:%s", x.toString0()))
    sb.WriteString("})")

    return sb.String()
}
type reqMyServiceSink struct {
    Sink int64 `thrift:"sink,1" json:"sink" db:"sink"`
}
// Compile time interface enforcer
var _ thrift.Struct = &reqMyServiceSink{}

// Deprecated: MyServiceSinkArgsDeprecated is deprecated, since it is supposed to be internal.
type MyServiceSinkArgsDeprecated = reqMyServiceSink

func newReqMyServiceSink() *reqMyServiceSink {
    return (&reqMyServiceSink{}).
        SetSinkNonCompat(0)
}

func (x *reqMyServiceSink) GetSinkNonCompat() int64 {
    return x.Sink
}

func (x *reqMyServiceSink) GetSink() int64 {
    return x.Sink
}

func (x *reqMyServiceSink) SetSinkNonCompat(value int64) *reqMyServiceSink {
    x.Sink = value
    return x
}

func (x *reqMyServiceSink) SetSink(value int64) *reqMyServiceSink {
    x.Sink = value
    return x
}

func (x *reqMyServiceSink) writeField1(p thrift.Format) error {  // Sink
    if err := p.WriteFieldBegin("sink", thrift.I64, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetSinkNonCompat()
    if err := p.WriteI64(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *reqMyServiceSink) readField1(p thrift.Format) error {  // Sink
    result, err := p.ReadI64()
if err != nil {
    return err
}

    x.SetSinkNonCompat(result)
    return nil
}

func (x *reqMyServiceSink) toString1() string {  // Sink
    return fmt.Sprintf("%v", x.GetSinkNonCompat())
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceSink().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqMyServiceSinkBuilder struct {
    obj *reqMyServiceSink
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceSink().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqMyServiceSinkBuilder() *reqMyServiceSinkBuilder {
    return &reqMyServiceSinkBuilder{
        obj: newReqMyServiceSink(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceSink().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceSinkBuilder) Sink(value int64) *reqMyServiceSinkBuilder {
    x.obj.Sink = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceSink().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceSinkBuilder) Emit() *reqMyServiceSink {
    var objCopy reqMyServiceSink = *x.obj
    return &objCopy
}

func (x *reqMyServiceSink) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqMyServiceSink"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 1 && wireType == thrift.Type(thrift.I64)):  // sink
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqMyServiceSink) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqMyServiceSink({")
    sb.WriteString(fmt.Sprintf("Sink:%s", x.toString1()))
    sb.WriteString("})")

    return sb.String()
}
type respMyServiceSink struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &respMyServiceSink{}
var _ thrift.WritableResult = &respMyServiceSink{}

// Deprecated: MyServiceSinkResultDeprecated is deprecated, since it is supposed to be internal.
type MyServiceSinkResultDeprecated = respMyServiceSink

func newRespMyServiceSink() *respMyServiceSink {
    return (&respMyServiceSink{})
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceSink().Set<FieldNameFoo>().Set<FieldNameBar>()
type respMyServiceSinkBuilder struct {
    obj *respMyServiceSink
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceSink().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespMyServiceSinkBuilder() *respMyServiceSinkBuilder {
    return &respMyServiceSinkBuilder{
        obj: newRespMyServiceSink(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceSink().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServiceSinkBuilder) Emit() *respMyServiceSink {
    var objCopy respMyServiceSink = *x.obj
    return &objCopy
}

func (x *respMyServiceSink) Exception() thrift.WritableException {
    return nil
}

func (x *respMyServiceSink) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respMyServiceSink"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respMyServiceSink) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respMyServiceSink({")
    sb.WriteString("})")

    return sb.String()
}
type reqMyServicePutDataById struct {
    Id int64 `thrift:"id,1" json:"id" db:"id"`
    Data string `thrift:"data,2" json:"data" db:"data"`
}
// Compile time interface enforcer
var _ thrift.Struct = &reqMyServicePutDataById{}

// Deprecated: MyServicePutDataByIdArgsDeprecated is deprecated, since it is supposed to be internal.
type MyServicePutDataByIdArgsDeprecated = reqMyServicePutDataById

func newReqMyServicePutDataById() *reqMyServicePutDataById {
    return (&reqMyServicePutDataById{}).
        SetIdNonCompat(0).
        SetDataNonCompat("")
}

func (x *reqMyServicePutDataById) GetIdNonCompat() int64 {
    return x.Id
}

func (x *reqMyServicePutDataById) GetId() int64 {
    return x.Id
}

func (x *reqMyServicePutDataById) GetDataNonCompat() string {
    return x.Data
}

func (x *reqMyServicePutDataById) GetData() string {
    return x.Data
}

func (x *reqMyServicePutDataById) SetIdNonCompat(value int64) *reqMyServicePutDataById {
    x.Id = value
    return x
}

func (x *reqMyServicePutDataById) SetId(value int64) *reqMyServicePutDataById {
    x.Id = value
    return x
}

func (x *reqMyServicePutDataById) SetDataNonCompat(value string) *reqMyServicePutDataById {
    x.Data = value
    return x
}

func (x *reqMyServicePutDataById) SetData(value string) *reqMyServicePutDataById {
    x.Data = value
    return x
}

func (x *reqMyServicePutDataById) writeField1(p thrift.Format) error {  // Id
    if err := p.WriteFieldBegin("id", thrift.I64, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetIdNonCompat()
    if err := p.WriteI64(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *reqMyServicePutDataById) writeField2(p thrift.Format) error {  // Data
    if err := p.WriteFieldBegin("data", thrift.STRING, 2); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetDataNonCompat()
    if err := p.WriteString(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *reqMyServicePutDataById) readField1(p thrift.Format) error {  // Id
    result, err := p.ReadI64()
if err != nil {
    return err
}

    x.SetIdNonCompat(result)
    return nil
}

func (x *reqMyServicePutDataById) readField2(p thrift.Format) error {  // Data
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetDataNonCompat(result)
    return nil
}

func (x *reqMyServicePutDataById) toString1() string {  // Id
    return fmt.Sprintf("%v", x.GetIdNonCompat())
}

func (x *reqMyServicePutDataById) toString2() string {  // Data
    return fmt.Sprintf("%v", x.GetDataNonCompat())
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServicePutDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqMyServicePutDataByIdBuilder struct {
    obj *reqMyServicePutDataById
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServicePutDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqMyServicePutDataByIdBuilder() *reqMyServicePutDataByIdBuilder {
    return &reqMyServicePutDataByIdBuilder{
        obj: newReqMyServicePutDataById(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServicePutDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServicePutDataByIdBuilder) Id(value int64) *reqMyServicePutDataByIdBuilder {
    x.obj.Id = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServicePutDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServicePutDataByIdBuilder) Data(value string) *reqMyServicePutDataByIdBuilder {
    x.obj.Data = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServicePutDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServicePutDataByIdBuilder) Emit() *reqMyServicePutDataById {
    var objCopy reqMyServicePutDataById = *x.obj
    return &objCopy
}

func (x *reqMyServicePutDataById) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqMyServicePutDataById"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := x.writeField2(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 1 && wireType == thrift.Type(thrift.I64)):  // id
            if err := x.readField1(p); err != nil {
                return err
            }
        case (id == 2 && wireType == thrift.Type(thrift.STRING)):  // data
            if err := x.readField2(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqMyServicePutDataById) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqMyServicePutDataById({")
    sb.WriteString(fmt.Sprintf("Id:%s ", x.toString1()))
    sb.WriteString(fmt.Sprintf("Data:%s", x.toString2()))
    sb.WriteString("})")

    return sb.String()
}
type respMyServicePutDataById struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &respMyServicePutDataById{}
var _ thrift.WritableResult = &respMyServicePutDataById{}

// Deprecated: MyServicePutDataByIdResultDeprecated is deprecated, since it is supposed to be internal.
type MyServicePutDataByIdResultDeprecated = respMyServicePutDataById

func newRespMyServicePutDataById() *respMyServicePutDataById {
    return (&respMyServicePutDataById{})
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServicePutDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
type respMyServicePutDataByIdBuilder struct {
    obj *respMyServicePutDataById
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServicePutDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespMyServicePutDataByIdBuilder() *respMyServicePutDataByIdBuilder {
    return &respMyServicePutDataByIdBuilder{
        obj: newRespMyServicePutDataById(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServicePutDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServicePutDataByIdBuilder) Emit() *respMyServicePutDataById {
    var objCopy respMyServicePutDataById = *x.obj
    return &objCopy
}

func (x *respMyServicePutDataById) Exception() thrift.WritableException {
    return nil
}

func (x *respMyServicePutDataById) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respMyServicePutDataById"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respMyServicePutDataById) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respMyServicePutDataById({")
    sb.WriteString("})")

    return sb.String()
}
type reqMyServiceHasDataById struct {
    Id int64 `thrift:"id,1" json:"id" db:"id"`
}
// Compile time interface enforcer
var _ thrift.Struct = &reqMyServiceHasDataById{}

// Deprecated: MyServiceHasDataByIdArgsDeprecated is deprecated, since it is supposed to be internal.
type MyServiceHasDataByIdArgsDeprecated = reqMyServiceHasDataById

func newReqMyServiceHasDataById() *reqMyServiceHasDataById {
    return (&reqMyServiceHasDataById{}).
        SetIdNonCompat(0)
}

func (x *reqMyServiceHasDataById) GetIdNonCompat() int64 {
    return x.Id
}

func (x *reqMyServiceHasDataById) GetId() int64 {
    return x.Id
}

func (x *reqMyServiceHasDataById) SetIdNonCompat(value int64) *reqMyServiceHasDataById {
    x.Id = value
    return x
}

func (x *reqMyServiceHasDataById) SetId(value int64) *reqMyServiceHasDataById {
    x.Id = value
    return x
}

func (x *reqMyServiceHasDataById) writeField1(p thrift.Format) error {  // Id
    if err := p.WriteFieldBegin("id", thrift.I64, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetIdNonCompat()
    if err := p.WriteI64(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *reqMyServiceHasDataById) readField1(p thrift.Format) error {  // Id
    result, err := p.ReadI64()
if err != nil {
    return err
}

    x.SetIdNonCompat(result)
    return nil
}

func (x *reqMyServiceHasDataById) toString1() string {  // Id
    return fmt.Sprintf("%v", x.GetIdNonCompat())
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceHasDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqMyServiceHasDataByIdBuilder struct {
    obj *reqMyServiceHasDataById
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceHasDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqMyServiceHasDataByIdBuilder() *reqMyServiceHasDataByIdBuilder {
    return &reqMyServiceHasDataByIdBuilder{
        obj: newReqMyServiceHasDataById(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceHasDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceHasDataByIdBuilder) Id(value int64) *reqMyServiceHasDataByIdBuilder {
    x.obj.Id = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceHasDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceHasDataByIdBuilder) Emit() *reqMyServiceHasDataById {
    var objCopy reqMyServiceHasDataById = *x.obj
    return &objCopy
}

func (x *reqMyServiceHasDataById) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqMyServiceHasDataById"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 1 && wireType == thrift.Type(thrift.I64)):  // id
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqMyServiceHasDataById) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqMyServiceHasDataById({")
    sb.WriteString(fmt.Sprintf("Id:%s", x.toString1()))
    sb.WriteString("})")

    return sb.String()
}
type respMyServiceHasDataById struct {
    Success *bool `thrift:"success,0,optional" json:"success,omitempty" db:"success"`
}
// Compile time interface enforcer
var _ thrift.Struct = &respMyServiceHasDataById{}
var _ thrift.WritableResult = &respMyServiceHasDataById{}

// Deprecated: MyServiceHasDataByIdResultDeprecated is deprecated, since it is supposed to be internal.
type MyServiceHasDataByIdResultDeprecated = respMyServiceHasDataById

func newRespMyServiceHasDataById() *respMyServiceHasDataById {
    return (&respMyServiceHasDataById{})
}

func (x *respMyServiceHasDataById) GetSuccessNonCompat() *bool {
    return x.Success
}

func (x *respMyServiceHasDataById) GetSuccess() bool {
    if !x.IsSetSuccess() {
        return false
    }

    return *x.Success
}

func (x *respMyServiceHasDataById) SetSuccessNonCompat(value bool) *respMyServiceHasDataById {
    x.Success = &value
    return x
}

func (x *respMyServiceHasDataById) SetSuccess(value *bool) *respMyServiceHasDataById {
    x.Success = value
    return x
}

func (x *respMyServiceHasDataById) IsSetSuccess() bool {
    return x != nil && x.Success != nil
}

func (x *respMyServiceHasDataById) writeField0(p thrift.Format) error {  // Success
    if !x.IsSetSuccess() {
        return nil
    }

    if err := p.WriteFieldBegin("success", thrift.BOOL, 0); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := *x.GetSuccessNonCompat()
    if err := p.WriteBool(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *respMyServiceHasDataById) readField0(p thrift.Format) error {  // Success
    result, err := p.ReadBool()
if err != nil {
    return err
}

    x.SetSuccessNonCompat(result)
    return nil
}

func (x *respMyServiceHasDataById) toString0() string {  // Success
    if x.IsSetSuccess() {
        return fmt.Sprintf("%v", *x.GetSuccessNonCompat())
    }
    return fmt.Sprintf("%v", x.GetSuccessNonCompat())
}



// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceHasDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
type respMyServiceHasDataByIdBuilder struct {
    obj *respMyServiceHasDataById
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceHasDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespMyServiceHasDataByIdBuilder() *respMyServiceHasDataByIdBuilder {
    return &respMyServiceHasDataByIdBuilder{
        obj: newRespMyServiceHasDataById(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceHasDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServiceHasDataByIdBuilder) Success(value *bool) *respMyServiceHasDataByIdBuilder {
    x.obj.Success = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceHasDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServiceHasDataByIdBuilder) Emit() *respMyServiceHasDataById {
    var objCopy respMyServiceHasDataById = *x.obj
    return &objCopy
}

func (x *respMyServiceHasDataById) Exception() thrift.WritableException {
    return nil
}

func (x *respMyServiceHasDataById) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respMyServiceHasDataById"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField0(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 0 && wireType == thrift.Type(thrift.BOOL)):  // success
            if err := x.readField0(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respMyServiceHasDataById) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respMyServiceHasDataById({")
    sb.WriteString(fmt.Sprintf("Success:%s", x.toString0()))
    sb.WriteString("})")

    return sb.String()
}
type reqMyServiceGetDataById struct {
    Id int64 `thrift:"id,1" json:"id" db:"id"`
}
// Compile time interface enforcer
var _ thrift.Struct = &reqMyServiceGetDataById{}

// Deprecated: MyServiceGetDataByIdArgsDeprecated is deprecated, since it is supposed to be internal.
type MyServiceGetDataByIdArgsDeprecated = reqMyServiceGetDataById

func newReqMyServiceGetDataById() *reqMyServiceGetDataById {
    return (&reqMyServiceGetDataById{}).
        SetIdNonCompat(0)
}

func (x *reqMyServiceGetDataById) GetIdNonCompat() int64 {
    return x.Id
}

func (x *reqMyServiceGetDataById) GetId() int64 {
    return x.Id
}

func (x *reqMyServiceGetDataById) SetIdNonCompat(value int64) *reqMyServiceGetDataById {
    x.Id = value
    return x
}

func (x *reqMyServiceGetDataById) SetId(value int64) *reqMyServiceGetDataById {
    x.Id = value
    return x
}

func (x *reqMyServiceGetDataById) writeField1(p thrift.Format) error {  // Id
    if err := p.WriteFieldBegin("id", thrift.I64, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetIdNonCompat()
    if err := p.WriteI64(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *reqMyServiceGetDataById) readField1(p thrift.Format) error {  // Id
    result, err := p.ReadI64()
if err != nil {
    return err
}

    x.SetIdNonCompat(result)
    return nil
}

func (x *reqMyServiceGetDataById) toString1() string {  // Id
    return fmt.Sprintf("%v", x.GetIdNonCompat())
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceGetDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqMyServiceGetDataByIdBuilder struct {
    obj *reqMyServiceGetDataById
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceGetDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqMyServiceGetDataByIdBuilder() *reqMyServiceGetDataByIdBuilder {
    return &reqMyServiceGetDataByIdBuilder{
        obj: newReqMyServiceGetDataById(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceGetDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceGetDataByIdBuilder) Id(value int64) *reqMyServiceGetDataByIdBuilder {
    x.obj.Id = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceGetDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceGetDataByIdBuilder) Emit() *reqMyServiceGetDataById {
    var objCopy reqMyServiceGetDataById = *x.obj
    return &objCopy
}

func (x *reqMyServiceGetDataById) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqMyServiceGetDataById"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 1 && wireType == thrift.Type(thrift.I64)):  // id
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqMyServiceGetDataById) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqMyServiceGetDataById({")
    sb.WriteString(fmt.Sprintf("Id:%s", x.toString1()))
    sb.WriteString("})")

    return sb.String()
}
type respMyServiceGetDataById struct {
    Success *string `thrift:"success,0,optional" json:"success,omitempty" db:"success"`
}
// Compile time interface enforcer
var _ thrift.Struct = &respMyServiceGetDataById{}
var _ thrift.WritableResult = &respMyServiceGetDataById{}

// Deprecated: MyServiceGetDataByIdResultDeprecated is deprecated, since it is supposed to be internal.
type MyServiceGetDataByIdResultDeprecated = respMyServiceGetDataById

func newRespMyServiceGetDataById() *respMyServiceGetDataById {
    return (&respMyServiceGetDataById{})
}

func (x *respMyServiceGetDataById) GetSuccessNonCompat() *string {
    return x.Success
}

func (x *respMyServiceGetDataById) GetSuccess() string {
    if !x.IsSetSuccess() {
        return ""
    }

    return *x.Success
}

func (x *respMyServiceGetDataById) SetSuccessNonCompat(value string) *respMyServiceGetDataById {
    x.Success = &value
    return x
}

func (x *respMyServiceGetDataById) SetSuccess(value *string) *respMyServiceGetDataById {
    x.Success = value
    return x
}

func (x *respMyServiceGetDataById) IsSetSuccess() bool {
    return x != nil && x.Success != nil
}

func (x *respMyServiceGetDataById) writeField0(p thrift.Format) error {  // Success
    if !x.IsSetSuccess() {
        return nil
    }

    if err := p.WriteFieldBegin("success", thrift.STRING, 0); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := *x.GetSuccessNonCompat()
    if err := p.WriteString(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *respMyServiceGetDataById) readField0(p thrift.Format) error {  // Success
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetSuccessNonCompat(result)
    return nil
}

func (x *respMyServiceGetDataById) toString0() string {  // Success
    if x.IsSetSuccess() {
        return fmt.Sprintf("%v", *x.GetSuccessNonCompat())
    }
    return fmt.Sprintf("%v", x.GetSuccessNonCompat())
}



// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceGetDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
type respMyServiceGetDataByIdBuilder struct {
    obj *respMyServiceGetDataById
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceGetDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespMyServiceGetDataByIdBuilder() *respMyServiceGetDataByIdBuilder {
    return &respMyServiceGetDataByIdBuilder{
        obj: newRespMyServiceGetDataById(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceGetDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServiceGetDataByIdBuilder) Success(value *string) *respMyServiceGetDataByIdBuilder {
    x.obj.Success = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceGetDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServiceGetDataByIdBuilder) Emit() *respMyServiceGetDataById {
    var objCopy respMyServiceGetDataById = *x.obj
    return &objCopy
}

func (x *respMyServiceGetDataById) Exception() thrift.WritableException {
    return nil
}

func (x *respMyServiceGetDataById) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respMyServiceGetDataById"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField0(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 0 && wireType == thrift.Type(thrift.STRING)):  // success
            if err := x.readField0(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respMyServiceGetDataById) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respMyServiceGetDataById({")
    sb.WriteString(fmt.Sprintf("Success:%s", x.toString0()))
    sb.WriteString("})")

    return sb.String()
}
type reqMyServiceDeleteDataById struct {
    Id int64 `thrift:"id,1" json:"id" db:"id"`
}
// Compile time interface enforcer
var _ thrift.Struct = &reqMyServiceDeleteDataById{}

// Deprecated: MyServiceDeleteDataByIdArgsDeprecated is deprecated, since it is supposed to be internal.
type MyServiceDeleteDataByIdArgsDeprecated = reqMyServiceDeleteDataById

func newReqMyServiceDeleteDataById() *reqMyServiceDeleteDataById {
    return (&reqMyServiceDeleteDataById{}).
        SetIdNonCompat(0)
}

func (x *reqMyServiceDeleteDataById) GetIdNonCompat() int64 {
    return x.Id
}

func (x *reqMyServiceDeleteDataById) GetId() int64 {
    return x.Id
}

func (x *reqMyServiceDeleteDataById) SetIdNonCompat(value int64) *reqMyServiceDeleteDataById {
    x.Id = value
    return x
}

func (x *reqMyServiceDeleteDataById) SetId(value int64) *reqMyServiceDeleteDataById {
    x.Id = value
    return x
}

func (x *reqMyServiceDeleteDataById) writeField1(p thrift.Format) error {  // Id
    if err := p.WriteFieldBegin("id", thrift.I64, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetIdNonCompat()
    if err := p.WriteI64(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *reqMyServiceDeleteDataById) readField1(p thrift.Format) error {  // Id
    result, err := p.ReadI64()
if err != nil {
    return err
}

    x.SetIdNonCompat(result)
    return nil
}

func (x *reqMyServiceDeleteDataById) toString1() string {  // Id
    return fmt.Sprintf("%v", x.GetIdNonCompat())
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceDeleteDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqMyServiceDeleteDataByIdBuilder struct {
    obj *reqMyServiceDeleteDataById
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceDeleteDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqMyServiceDeleteDataByIdBuilder() *reqMyServiceDeleteDataByIdBuilder {
    return &reqMyServiceDeleteDataByIdBuilder{
        obj: newReqMyServiceDeleteDataById(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceDeleteDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceDeleteDataByIdBuilder) Id(value int64) *reqMyServiceDeleteDataByIdBuilder {
    x.obj.Id = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceDeleteDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceDeleteDataByIdBuilder) Emit() *reqMyServiceDeleteDataById {
    var objCopy reqMyServiceDeleteDataById = *x.obj
    return &objCopy
}

func (x *reqMyServiceDeleteDataById) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqMyServiceDeleteDataById"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 1 && wireType == thrift.Type(thrift.I64)):  // id
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqMyServiceDeleteDataById) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqMyServiceDeleteDataById({")
    sb.WriteString(fmt.Sprintf("Id:%s", x.toString1()))
    sb.WriteString("})")

    return sb.String()
}
type respMyServiceDeleteDataById struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &respMyServiceDeleteDataById{}
var _ thrift.WritableResult = &respMyServiceDeleteDataById{}

// Deprecated: MyServiceDeleteDataByIdResultDeprecated is deprecated, since it is supposed to be internal.
type MyServiceDeleteDataByIdResultDeprecated = respMyServiceDeleteDataById

func newRespMyServiceDeleteDataById() *respMyServiceDeleteDataById {
    return (&respMyServiceDeleteDataById{})
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceDeleteDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
type respMyServiceDeleteDataByIdBuilder struct {
    obj *respMyServiceDeleteDataById
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceDeleteDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespMyServiceDeleteDataByIdBuilder() *respMyServiceDeleteDataByIdBuilder {
    return &respMyServiceDeleteDataByIdBuilder{
        obj: newRespMyServiceDeleteDataById(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceDeleteDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServiceDeleteDataByIdBuilder) Emit() *respMyServiceDeleteDataById {
    var objCopy respMyServiceDeleteDataById = *x.obj
    return &objCopy
}

func (x *respMyServiceDeleteDataById) Exception() thrift.WritableException {
    return nil
}

func (x *respMyServiceDeleteDataById) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respMyServiceDeleteDataById"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respMyServiceDeleteDataById) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respMyServiceDeleteDataById({")
    sb.WriteString("})")

    return sb.String()
}
type reqMyServiceLobDataById struct {
    Id int64 `thrift:"id,1" json:"id" db:"id"`
    Data string `thrift:"data,2" json:"data" db:"data"`
}
// Compile time interface enforcer
var _ thrift.Struct = &reqMyServiceLobDataById{}

// Deprecated: MyServiceLobDataByIdArgsDeprecated is deprecated, since it is supposed to be internal.
type MyServiceLobDataByIdArgsDeprecated = reqMyServiceLobDataById

func newReqMyServiceLobDataById() *reqMyServiceLobDataById {
    return (&reqMyServiceLobDataById{}).
        SetIdNonCompat(0).
        SetDataNonCompat("")
}

func (x *reqMyServiceLobDataById) GetIdNonCompat() int64 {
    return x.Id
}

func (x *reqMyServiceLobDataById) GetId() int64 {
    return x.Id
}

func (x *reqMyServiceLobDataById) GetDataNonCompat() string {
    return x.Data
}

func (x *reqMyServiceLobDataById) GetData() string {
    return x.Data
}

func (x *reqMyServiceLobDataById) SetIdNonCompat(value int64) *reqMyServiceLobDataById {
    x.Id = value
    return x
}

func (x *reqMyServiceLobDataById) SetId(value int64) *reqMyServiceLobDataById {
    x.Id = value
    return x
}

func (x *reqMyServiceLobDataById) SetDataNonCompat(value string) *reqMyServiceLobDataById {
    x.Data = value
    return x
}

func (x *reqMyServiceLobDataById) SetData(value string) *reqMyServiceLobDataById {
    x.Data = value
    return x
}

func (x *reqMyServiceLobDataById) writeField1(p thrift.Format) error {  // Id
    if err := p.WriteFieldBegin("id", thrift.I64, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetIdNonCompat()
    if err := p.WriteI64(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *reqMyServiceLobDataById) writeField2(p thrift.Format) error {  // Data
    if err := p.WriteFieldBegin("data", thrift.STRING, 2); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetDataNonCompat()
    if err := p.WriteString(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *reqMyServiceLobDataById) readField1(p thrift.Format) error {  // Id
    result, err := p.ReadI64()
if err != nil {
    return err
}

    x.SetIdNonCompat(result)
    return nil
}

func (x *reqMyServiceLobDataById) readField2(p thrift.Format) error {  // Data
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetDataNonCompat(result)
    return nil
}

func (x *reqMyServiceLobDataById) toString1() string {  // Id
    return fmt.Sprintf("%v", x.GetIdNonCompat())
}

func (x *reqMyServiceLobDataById) toString2() string {  // Data
    return fmt.Sprintf("%v", x.GetDataNonCompat())
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceLobDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqMyServiceLobDataByIdBuilder struct {
    obj *reqMyServiceLobDataById
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceLobDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqMyServiceLobDataByIdBuilder() *reqMyServiceLobDataByIdBuilder {
    return &reqMyServiceLobDataByIdBuilder{
        obj: newReqMyServiceLobDataById(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceLobDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceLobDataByIdBuilder) Id(value int64) *reqMyServiceLobDataByIdBuilder {
    x.obj.Id = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceLobDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceLobDataByIdBuilder) Data(value string) *reqMyServiceLobDataByIdBuilder {
    x.obj.Data = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceLobDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceLobDataByIdBuilder) Emit() *reqMyServiceLobDataById {
    var objCopy reqMyServiceLobDataById = *x.obj
    return &objCopy
}

func (x *reqMyServiceLobDataById) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqMyServiceLobDataById"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := x.writeField2(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 1 && wireType == thrift.Type(thrift.I64)):  // id
            if err := x.readField1(p); err != nil {
                return err
            }
        case (id == 2 && wireType == thrift.Type(thrift.STRING)):  // data
            if err := x.readField2(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqMyServiceLobDataById) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqMyServiceLobDataById({")
    sb.WriteString(fmt.Sprintf("Id:%s ", x.toString1()))
    sb.WriteString(fmt.Sprintf("Data:%s", x.toString2()))
    sb.WriteString("})")

    return sb.String()
}
type respMyServiceLobDataById struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &respMyServiceLobDataById{}
var _ thrift.WritableResult = &respMyServiceLobDataById{}

// Deprecated: MyServiceLobDataByIdResultDeprecated is deprecated, since it is supposed to be internal.
type MyServiceLobDataByIdResultDeprecated = respMyServiceLobDataById

func newRespMyServiceLobDataById() *respMyServiceLobDataById {
    return (&respMyServiceLobDataById{})
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceLobDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
type respMyServiceLobDataByIdBuilder struct {
    obj *respMyServiceLobDataById
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceLobDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespMyServiceLobDataByIdBuilder() *respMyServiceLobDataByIdBuilder {
    return &respMyServiceLobDataByIdBuilder{
        obj: newRespMyServiceLobDataById(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceLobDataById().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServiceLobDataByIdBuilder) Emit() *respMyServiceLobDataById {
    var objCopy respMyServiceLobDataById = *x.obj
    return &objCopy
}

func (x *respMyServiceLobDataById) Exception() thrift.WritableException {
    return nil
}

func (x *respMyServiceLobDataById) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respMyServiceLobDataById"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respMyServiceLobDataById) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respMyServiceLobDataById({")
    sb.WriteString("})")

    return sb.String()
}
type reqMyServiceInvalidReturnForHack struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &reqMyServiceInvalidReturnForHack{}

// Deprecated: MyServiceInvalidReturnForHackArgsDeprecated is deprecated, since it is supposed to be internal.
type MyServiceInvalidReturnForHackArgsDeprecated = reqMyServiceInvalidReturnForHack

func newReqMyServiceInvalidReturnForHack() *reqMyServiceInvalidReturnForHack {
    return (&reqMyServiceInvalidReturnForHack{})
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceInvalidReturnForHack().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqMyServiceInvalidReturnForHackBuilder struct {
    obj *reqMyServiceInvalidReturnForHack
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceInvalidReturnForHack().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqMyServiceInvalidReturnForHackBuilder() *reqMyServiceInvalidReturnForHackBuilder {
    return &reqMyServiceInvalidReturnForHackBuilder{
        obj: newReqMyServiceInvalidReturnForHack(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceInvalidReturnForHack().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceInvalidReturnForHackBuilder) Emit() *reqMyServiceInvalidReturnForHack {
    var objCopy reqMyServiceInvalidReturnForHack = *x.obj
    return &objCopy
}

func (x *reqMyServiceInvalidReturnForHack) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqMyServiceInvalidReturnForHack"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqMyServiceInvalidReturnForHack) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqMyServiceInvalidReturnForHack({")
    sb.WriteString("})")

    return sb.String()
}
type respMyServiceInvalidReturnForHack struct {
    Success []float32 `thrift:"success,0,optional" json:"success,omitempty" db:"success"`
}
// Compile time interface enforcer
var _ thrift.Struct = &respMyServiceInvalidReturnForHack{}
var _ thrift.WritableResult = &respMyServiceInvalidReturnForHack{}

// Deprecated: MyServiceInvalidReturnForHackResultDeprecated is deprecated, since it is supposed to be internal.
type MyServiceInvalidReturnForHackResultDeprecated = respMyServiceInvalidReturnForHack

func newRespMyServiceInvalidReturnForHack() *respMyServiceInvalidReturnForHack {
    return (&respMyServiceInvalidReturnForHack{})
}

func (x *respMyServiceInvalidReturnForHack) GetSuccessNonCompat() []float32 {
    return x.Success
}

func (x *respMyServiceInvalidReturnForHack) GetSuccess() []float32 {
    if !x.IsSetSuccess() {
        return make([]float32, 0)
    }

    return x.Success
}

func (x *respMyServiceInvalidReturnForHack) SetSuccessNonCompat(value []float32) *respMyServiceInvalidReturnForHack {
    x.Success = value
    return x
}

func (x *respMyServiceInvalidReturnForHack) SetSuccess(value []float32) *respMyServiceInvalidReturnForHack {
    x.Success = value
    return x
}

func (x *respMyServiceInvalidReturnForHack) IsSetSuccess() bool {
    return x != nil && x.Success != nil
}

func (x *respMyServiceInvalidReturnForHack) writeField0(p thrift.Format) error {  // Success
    if !x.IsSetSuccess() {
        return nil
    }

    if err := p.WriteFieldBegin("success", thrift.SET, 0); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetSuccessNonCompat()
    if err := p.WriteSetBegin(thrift.FLOAT, len(item)); err != nil {
    return thrift.PrependError("error writing set begin: ", err)
}
for _, v := range item {
    {
        item := v
        if err := p.WriteFloat(item); err != nil {
    return err
}
    }
}
if err := p.WriteSetEnd(); err != nil {
    return thrift.PrependError("error writing set end: ", err)
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *respMyServiceInvalidReturnForHack) readField0(p thrift.Format) error {  // Success
    _ /* elemType */, size, err := p.ReadSetBegin()
if err != nil {
    return thrift.PrependError("error reading set begin: ", err)
}

setResult := make([]float32, 0, size)
for i := 0; i < size; i++ {
    var elem float32
    {
        result, err := p.ReadFloat()
if err != nil {
    return err
}
        elem = result
    }
    setResult = append(setResult, elem)
}

if err := p.ReadSetEnd(); err != nil {
    return thrift.PrependError("error reading set end: ", err)
}
result := setResult

    x.SetSuccessNonCompat(result)
    return nil
}

func (x *respMyServiceInvalidReturnForHack) toString0() string {  // Success
    return fmt.Sprintf("%v", x.GetSuccessNonCompat())
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceInvalidReturnForHack().Set<FieldNameFoo>().Set<FieldNameBar>()
type respMyServiceInvalidReturnForHackBuilder struct {
    obj *respMyServiceInvalidReturnForHack
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceInvalidReturnForHack().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespMyServiceInvalidReturnForHackBuilder() *respMyServiceInvalidReturnForHackBuilder {
    return &respMyServiceInvalidReturnForHackBuilder{
        obj: newRespMyServiceInvalidReturnForHack(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceInvalidReturnForHack().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServiceInvalidReturnForHackBuilder) Success(value []float32) *respMyServiceInvalidReturnForHackBuilder {
    x.obj.Success = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceInvalidReturnForHack().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServiceInvalidReturnForHackBuilder) Emit() *respMyServiceInvalidReturnForHack {
    var objCopy respMyServiceInvalidReturnForHack = *x.obj
    return &objCopy
}

func (x *respMyServiceInvalidReturnForHack) Exception() thrift.WritableException {
    return nil
}

func (x *respMyServiceInvalidReturnForHack) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respMyServiceInvalidReturnForHack"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField0(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 0 && wireType == thrift.Type(thrift.SET)):  // success
            if err := x.readField0(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respMyServiceInvalidReturnForHack) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respMyServiceInvalidReturnForHack({")
    sb.WriteString(fmt.Sprintf("Success:%s", x.toString0()))
    sb.WriteString("})")

    return sb.String()
}
type reqMyServiceRpcSkippedCodegen struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &reqMyServiceRpcSkippedCodegen{}

// Deprecated: MyServiceRpcSkippedCodegenArgsDeprecated is deprecated, since it is supposed to be internal.
type MyServiceRpcSkippedCodegenArgsDeprecated = reqMyServiceRpcSkippedCodegen

func newReqMyServiceRpcSkippedCodegen() *reqMyServiceRpcSkippedCodegen {
    return (&reqMyServiceRpcSkippedCodegen{})
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceRpcSkippedCodegen().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqMyServiceRpcSkippedCodegenBuilder struct {
    obj *reqMyServiceRpcSkippedCodegen
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceRpcSkippedCodegen().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqMyServiceRpcSkippedCodegenBuilder() *reqMyServiceRpcSkippedCodegenBuilder {
    return &reqMyServiceRpcSkippedCodegenBuilder{
        obj: newReqMyServiceRpcSkippedCodegen(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqMyServiceRpcSkippedCodegen().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqMyServiceRpcSkippedCodegenBuilder) Emit() *reqMyServiceRpcSkippedCodegen {
    var objCopy reqMyServiceRpcSkippedCodegen = *x.obj
    return &objCopy
}

func (x *reqMyServiceRpcSkippedCodegen) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqMyServiceRpcSkippedCodegen"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqMyServiceRpcSkippedCodegen) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqMyServiceRpcSkippedCodegen({")
    sb.WriteString("})")

    return sb.String()
}
type respMyServiceRpcSkippedCodegen struct {
}
// Compile time interface enforcer
var _ thrift.Struct = &respMyServiceRpcSkippedCodegen{}
var _ thrift.WritableResult = &respMyServiceRpcSkippedCodegen{}

// Deprecated: MyServiceRpcSkippedCodegenResultDeprecated is deprecated, since it is supposed to be internal.
type MyServiceRpcSkippedCodegenResultDeprecated = respMyServiceRpcSkippedCodegen

func newRespMyServiceRpcSkippedCodegen() *respMyServiceRpcSkippedCodegen {
    return (&respMyServiceRpcSkippedCodegen{})
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceRpcSkippedCodegen().Set<FieldNameFoo>().Set<FieldNameBar>()
type respMyServiceRpcSkippedCodegenBuilder struct {
    obj *respMyServiceRpcSkippedCodegen
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceRpcSkippedCodegen().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespMyServiceRpcSkippedCodegenBuilder() *respMyServiceRpcSkippedCodegenBuilder {
    return &respMyServiceRpcSkippedCodegenBuilder{
        obj: newRespMyServiceRpcSkippedCodegen(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespMyServiceRpcSkippedCodegen().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respMyServiceRpcSkippedCodegenBuilder) Emit() *respMyServiceRpcSkippedCodegen {
    var objCopy respMyServiceRpcSkippedCodegen = *x.obj
    return &objCopy
}

func (x *respMyServiceRpcSkippedCodegen) Exception() thrift.WritableException {
    return nil
}

func (x *respMyServiceRpcSkippedCodegen) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respMyServiceRpcSkippedCodegen"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respMyServiceRpcSkippedCodegen) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respMyServiceRpcSkippedCodegen({")
    sb.WriteString("})")

    return sb.String()
}


type MyServiceProcessor struct {
    processorMap       map[string]thrift.ProcessorFunctionContext
    functionServiceMap map[string]string
    handler            MyService
}
// Compile time interface enforcer
var _ thrift.ProcessorContext = &MyServiceProcessor{}

func NewMyServiceProcessor(handler MyService) *MyServiceProcessor {
    p := &MyServiceProcessor{
        handler:            handler,
        processorMap:       make(map[string]thrift.ProcessorFunctionContext),
        functionServiceMap: make(map[string]string),
    }
    p.AddToProcessorMap("ping", &procFuncMyServicePing{handler: handler})
    p.AddToProcessorMap("getRandomData", &procFuncMyServiceGetRandomData{handler: handler})
    p.AddToProcessorMap("sink", &procFuncMyServiceSink{handler: handler})
    p.AddToProcessorMap("putDataById", &procFuncMyServicePutDataById{handler: handler})
    p.AddToProcessorMap("hasDataById", &procFuncMyServiceHasDataById{handler: handler})
    p.AddToProcessorMap("getDataById", &procFuncMyServiceGetDataById{handler: handler})
    p.AddToProcessorMap("deleteDataById", &procFuncMyServiceDeleteDataById{handler: handler})
    p.AddToProcessorMap("lobDataById", &procFuncMyServiceLobDataById{handler: handler})
    p.AddToProcessorMap("invalid_return_for_hack", &procFuncMyServiceInvalidReturnForHack{handler: handler})
    p.AddToProcessorMap("rpc_skipped_codegen", &procFuncMyServiceRpcSkippedCodegen{handler: handler})
    p.AddToFunctionServiceMap("ping", "MyService")
    p.AddToFunctionServiceMap("getRandomData", "MyService")
    p.AddToFunctionServiceMap("sink", "MyService")
    p.AddToFunctionServiceMap("putDataById", "MyService")
    p.AddToFunctionServiceMap("hasDataById", "MyService")
    p.AddToFunctionServiceMap("getDataById", "MyService")
    p.AddToFunctionServiceMap("deleteDataById", "MyService")
    p.AddToFunctionServiceMap("lobDataById", "MyService")
    p.AddToFunctionServiceMap("invalid_return_for_hack", "MyService")
    p.AddToFunctionServiceMap("rpc_skipped_codegen", "MyService")

    return p
}

func (p *MyServiceProcessor) AddToProcessorMap(key string, processor thrift.ProcessorFunctionContext) {
    p.processorMap[key] = processor
}

func (p *MyServiceProcessor) AddToFunctionServiceMap(key, service string) {
    p.functionServiceMap[key] = service
}

func (p *MyServiceProcessor) GetProcessorFunctionContext(key string) (processor thrift.ProcessorFunctionContext, err error) {
    if processor, ok := p.processorMap[key]; ok {
        return processor, nil
    }
    return nil, nil
}

func (p *MyServiceProcessor) ProcessorMap() map[string]thrift.ProcessorFunctionContext {
    return p.processorMap
}

func (p *MyServiceProcessor) FunctionServiceMap() map[string]string {
    return p.functionServiceMap
}

func (p *MyServiceProcessor) GetThriftMetadata() *metadata.ThriftMetadata {
    return GetThriftMetadataForService("module.MyService")
}


type procFuncMyServicePing struct {
    handler MyService
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncMyServicePing{}

func (p *procFuncMyServicePing) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqMyServicePing()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncMyServicePing) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("ping", messageType, 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
    }
    return err
}

func (p *procFuncMyServicePing) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    result := newRespMyServicePing()
    err := p.handler.Ping(ctx)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing Ping: " + err.Error(), err)
        return x, x
    }

    return result, nil
}


type procFuncMyServiceGetRandomData struct {
    handler MyService
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncMyServiceGetRandomData{}

func (p *procFuncMyServiceGetRandomData) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqMyServiceGetRandomData()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncMyServiceGetRandomData) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("getRandomData", messageType, 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
    }
    return err
}

func (p *procFuncMyServiceGetRandomData) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    result := newRespMyServiceGetRandomData()
    retval, err := p.handler.GetRandomData(ctx)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing GetRandomData: " + err.Error(), err)
        return x, x
    }

    result.Success = &retval
    return result, nil
}


type procFuncMyServiceSink struct {
    handler MyService
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncMyServiceSink{}

func (p *procFuncMyServiceSink) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqMyServiceSink()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncMyServiceSink) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("sink", messageType, 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
    }
    return err
}

func (p *procFuncMyServiceSink) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    args := reqStruct.(*reqMyServiceSink)
    result := newRespMyServiceSink()
    err := p.handler.Sink(ctx, args.Sink)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing Sink: " + err.Error(), err)
        return x, x
    }

    return result, nil
}


type procFuncMyServicePutDataById struct {
    handler MyService
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncMyServicePutDataById{}

func (p *procFuncMyServicePutDataById) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqMyServicePutDataById()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncMyServicePutDataById) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("putDataById", messageType, 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
    }
    return err
}

func (p *procFuncMyServicePutDataById) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    args := reqStruct.(*reqMyServicePutDataById)
    result := newRespMyServicePutDataById()
    err := p.handler.PutDataById(ctx, args.Id, args.Data)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing PutDataById: " + err.Error(), err)
        return x, x
    }

    return result, nil
}


type procFuncMyServiceHasDataById struct {
    handler MyService
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncMyServiceHasDataById{}

func (p *procFuncMyServiceHasDataById) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqMyServiceHasDataById()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncMyServiceHasDataById) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("hasDataById", messageType, 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
    }
    return err
}

func (p *procFuncMyServiceHasDataById) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    args := reqStruct.(*reqMyServiceHasDataById)
    result := newRespMyServiceHasDataById()
    retval, err := p.handler.HasDataById(ctx, args.Id)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing HasDataById: " + err.Error(), err)
        return x, x
    }

    result.Success = &retval
    return result, nil
}


type procFuncMyServiceGetDataById struct {
    handler MyService
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncMyServiceGetDataById{}

func (p *procFuncMyServiceGetDataById) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqMyServiceGetDataById()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncMyServiceGetDataById) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("getDataById", messageType, 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
    }
    return err
}

func (p *procFuncMyServiceGetDataById) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    args := reqStruct.(*reqMyServiceGetDataById)
    result := newRespMyServiceGetDataById()
    retval, err := p.handler.GetDataById(ctx, args.Id)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing GetDataById: " + err.Error(), err)
        return x, x
    }

    result.Success = &retval
    return result, nil
}


type procFuncMyServiceDeleteDataById struct {
    handler MyService
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncMyServiceDeleteDataById{}

func (p *procFuncMyServiceDeleteDataById) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqMyServiceDeleteDataById()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncMyServiceDeleteDataById) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("deleteDataById", messageType, 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
    }
    return err
}

func (p *procFuncMyServiceDeleteDataById) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    args := reqStruct.(*reqMyServiceDeleteDataById)
    result := newRespMyServiceDeleteDataById()
    err := p.handler.DeleteDataById(ctx, args.Id)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing DeleteDataById: " + err.Error(), err)
        return x, x
    }

    return result, nil
}


type procFuncMyServiceLobDataById struct {
    handler MyService
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncMyServiceLobDataById{}

func (p *procFuncMyServiceLobDataById) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqMyServiceLobDataById()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncMyServiceLobDataById) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("lobDataById", messageType, 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
    }
    return err
}

func (p *procFuncMyServiceLobDataById) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    args := reqStruct.(*reqMyServiceLobDataById)
    err := p.handler.LobDataById(ctx, args.Id, args.Data)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing LobDataById: " + err.Error(), err)
        return x, x
    }

    return nil, nil
}


type procFuncMyServiceInvalidReturnForHack struct {
    handler MyService
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncMyServiceInvalidReturnForHack{}

func (p *procFuncMyServiceInvalidReturnForHack) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqMyServiceInvalidReturnForHack()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncMyServiceInvalidReturnForHack) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("invalid_return_for_hack", messageType, 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
    }
    return err
}

func (p *procFuncMyServiceInvalidReturnForHack) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    result := newRespMyServiceInvalidReturnForHack()
    retval, err := p.handler.InvalidReturnForHack(ctx)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing InvalidReturnForHack: " + err.Error(), err)
        return x, x
    }

    result.Success = retval
    return result, nil
}


type procFuncMyServiceRpcSkippedCodegen struct {
    handler MyService
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncMyServiceRpcSkippedCodegen{}

func (p *procFuncMyServiceRpcSkippedCodegen) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqMyServiceRpcSkippedCodegen()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncMyServiceRpcSkippedCodegen) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("rpc_skipped_codegen", messageType, 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
    }
    return err
}

func (p *procFuncMyServiceRpcSkippedCodegen) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    result := newRespMyServiceRpcSkippedCodegen()
    err := p.handler.RpcSkippedCodegen(ctx)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing RpcSkippedCodegen: " + err.Error(), err)
        return x, x
    }

    return result, nil
}




type DbMixedStackArguments interface {
    GetDataByKey0(ctx context.Context, key string) ([]byte, error)
    GetDataByKey1(ctx context.Context, key string) ([]byte, error)
}

type DbMixedStackArgumentsChannelClientInterface interface {
    thrift.ClientInterface
    DbMixedStackArguments
}

type DbMixedStackArgumentsClientInterface interface {
    thrift.ClientInterface
    GetDataByKey0(key string) ([]byte, error)
    GetDataByKey1(key string) ([]byte, error)
}

type DbMixedStackArgumentsContextClientInterface interface {
    DbMixedStackArgumentsClientInterface
    GetDataByKey0Context(ctx context.Context, key string) ([]byte, error)
    GetDataByKey1Context(ctx context.Context, key string) ([]byte, error)
}

type DbMixedStackArgumentsChannelClient struct {
    ch thrift.RequestChannel
}
// Compile time interface enforcer
var _ DbMixedStackArgumentsChannelClientInterface = &DbMixedStackArgumentsChannelClient{}

func NewDbMixedStackArgumentsChannelClient(channel thrift.RequestChannel) *DbMixedStackArgumentsChannelClient {
    return &DbMixedStackArgumentsChannelClient{
        ch: channel,
    }
}

func (c *DbMixedStackArgumentsChannelClient) Close() error {
    return c.ch.Close()
}

type DbMixedStackArgumentsClient struct {
    chClient *DbMixedStackArgumentsChannelClient
    Mu       sync.Mutex
}
// Compile time interface enforcer
var _ DbMixedStackArgumentsClientInterface = &DbMixedStackArgumentsClient{}
var _ DbMixedStackArgumentsContextClientInterface = &DbMixedStackArgumentsClient{}

func NewDbMixedStackArgumentsClient(prot thrift.Protocol) *DbMixedStackArgumentsClient {
    return &DbMixedStackArgumentsClient{
        chClient: NewDbMixedStackArgumentsChannelClient(
            thrift.NewSerialChannel(prot),
        ),
    }
}

func (c *DbMixedStackArgumentsClient) Close() error {
    return c.chClient.Close()
}

func (c *DbMixedStackArgumentsChannelClient) GetDataByKey0(ctx context.Context, key string) ([]byte, error) {
    in := &reqDbMixedStackArgumentsGetDataByKey0{
        Key: key,
    }
    out := newRespDbMixedStackArgumentsGetDataByKey0()
    err := c.ch.Call(ctx, "getDataByKey0", in, out)
    if err != nil {
        return nil, err
    }
    return out.GetSuccess(), nil
}

func (c *DbMixedStackArgumentsClient) GetDataByKey0(key string) ([]byte, error) {
    return c.chClient.GetDataByKey0(context.Background(), key)
}

func (c *DbMixedStackArgumentsClient) GetDataByKey0Context(ctx context.Context, key string) ([]byte, error) {
    return c.chClient.GetDataByKey0(ctx, key)
}

func (c *DbMixedStackArgumentsChannelClient) GetDataByKey1(ctx context.Context, key string) ([]byte, error) {
    in := &reqDbMixedStackArgumentsGetDataByKey1{
        Key: key,
    }
    out := newRespDbMixedStackArgumentsGetDataByKey1()
    err := c.ch.Call(ctx, "getDataByKey1", in, out)
    if err != nil {
        return nil, err
    }
    return out.GetSuccess(), nil
}

func (c *DbMixedStackArgumentsClient) GetDataByKey1(key string) ([]byte, error) {
    return c.chClient.GetDataByKey1(context.Background(), key)
}

func (c *DbMixedStackArgumentsClient) GetDataByKey1Context(ctx context.Context, key string) ([]byte, error) {
    return c.chClient.GetDataByKey1(ctx, key)
}

type reqDbMixedStackArgumentsGetDataByKey0 struct {
    Key string `thrift:"key,1" json:"key" db:"key"`
}
// Compile time interface enforcer
var _ thrift.Struct = &reqDbMixedStackArgumentsGetDataByKey0{}

// Deprecated: DbMixedStackArgumentsGetDataByKey0ArgsDeprecated is deprecated, since it is supposed to be internal.
type DbMixedStackArgumentsGetDataByKey0ArgsDeprecated = reqDbMixedStackArgumentsGetDataByKey0

func newReqDbMixedStackArgumentsGetDataByKey0() *reqDbMixedStackArgumentsGetDataByKey0 {
    return (&reqDbMixedStackArgumentsGetDataByKey0{}).
        SetKeyNonCompat("")
}

func (x *reqDbMixedStackArgumentsGetDataByKey0) GetKeyNonCompat() string {
    return x.Key
}

func (x *reqDbMixedStackArgumentsGetDataByKey0) GetKey() string {
    return x.Key
}

func (x *reqDbMixedStackArgumentsGetDataByKey0) SetKeyNonCompat(value string) *reqDbMixedStackArgumentsGetDataByKey0 {
    x.Key = value
    return x
}

func (x *reqDbMixedStackArgumentsGetDataByKey0) SetKey(value string) *reqDbMixedStackArgumentsGetDataByKey0 {
    x.Key = value
    return x
}

func (x *reqDbMixedStackArgumentsGetDataByKey0) writeField1(p thrift.Format) error {  // Key
    if err := p.WriteFieldBegin("key", thrift.STRING, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetKeyNonCompat()
    if err := p.WriteString(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *reqDbMixedStackArgumentsGetDataByKey0) readField1(p thrift.Format) error {  // Key
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetKeyNonCompat(result)
    return nil
}

func (x *reqDbMixedStackArgumentsGetDataByKey0) toString1() string {  // Key
    return fmt.Sprintf("%v", x.GetKeyNonCompat())
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqDbMixedStackArgumentsGetDataByKey0().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqDbMixedStackArgumentsGetDataByKey0Builder struct {
    obj *reqDbMixedStackArgumentsGetDataByKey0
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqDbMixedStackArgumentsGetDataByKey0().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqDbMixedStackArgumentsGetDataByKey0Builder() *reqDbMixedStackArgumentsGetDataByKey0Builder {
    return &reqDbMixedStackArgumentsGetDataByKey0Builder{
        obj: newReqDbMixedStackArgumentsGetDataByKey0(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqDbMixedStackArgumentsGetDataByKey0().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqDbMixedStackArgumentsGetDataByKey0Builder) Key(value string) *reqDbMixedStackArgumentsGetDataByKey0Builder {
    x.obj.Key = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqDbMixedStackArgumentsGetDataByKey0().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqDbMixedStackArgumentsGetDataByKey0Builder) Emit() *reqDbMixedStackArgumentsGetDataByKey0 {
    var objCopy reqDbMixedStackArgumentsGetDataByKey0 = *x.obj
    return &objCopy
}

func (x *reqDbMixedStackArgumentsGetDataByKey0) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqDbMixedStackArgumentsGetDataByKey0"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 1 && wireType == thrift.Type(thrift.STRING)):  // key
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqDbMixedStackArgumentsGetDataByKey0) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqDbMixedStackArgumentsGetDataByKey0({")
    sb.WriteString(fmt.Sprintf("Key:%s", x.toString1()))
    sb.WriteString("})")

    return sb.String()
}
type respDbMixedStackArgumentsGetDataByKey0 struct {
    Success []byte `thrift:"success,0,optional" json:"success,omitempty" db:"success"`
}
// Compile time interface enforcer
var _ thrift.Struct = &respDbMixedStackArgumentsGetDataByKey0{}
var _ thrift.WritableResult = &respDbMixedStackArgumentsGetDataByKey0{}

// Deprecated: DbMixedStackArgumentsGetDataByKey0ResultDeprecated is deprecated, since it is supposed to be internal.
type DbMixedStackArgumentsGetDataByKey0ResultDeprecated = respDbMixedStackArgumentsGetDataByKey0

func newRespDbMixedStackArgumentsGetDataByKey0() *respDbMixedStackArgumentsGetDataByKey0 {
    return (&respDbMixedStackArgumentsGetDataByKey0{})
}

func (x *respDbMixedStackArgumentsGetDataByKey0) GetSuccessNonCompat() []byte {
    return x.Success
}

func (x *respDbMixedStackArgumentsGetDataByKey0) GetSuccess() []byte {
    if !x.IsSetSuccess() {
        return []byte("")
    }

    return x.Success
}

func (x *respDbMixedStackArgumentsGetDataByKey0) SetSuccessNonCompat(value []byte) *respDbMixedStackArgumentsGetDataByKey0 {
    x.Success = value
    return x
}

func (x *respDbMixedStackArgumentsGetDataByKey0) SetSuccess(value []byte) *respDbMixedStackArgumentsGetDataByKey0 {
    x.Success = value
    return x
}

func (x *respDbMixedStackArgumentsGetDataByKey0) IsSetSuccess() bool {
    return x != nil && x.Success != nil
}

func (x *respDbMixedStackArgumentsGetDataByKey0) writeField0(p thrift.Format) error {  // Success
    if !x.IsSetSuccess() {
        return nil
    }

    if err := p.WriteFieldBegin("success", thrift.STRING, 0); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetSuccessNonCompat()
    if err := p.WriteBinary(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *respDbMixedStackArgumentsGetDataByKey0) readField0(p thrift.Format) error {  // Success
    result, err := p.ReadBinary()
if err != nil {
    return err
}

    x.SetSuccessNonCompat(result)
    return nil
}

func (x *respDbMixedStackArgumentsGetDataByKey0) toString0() string {  // Success
    return fmt.Sprintf("%v", x.GetSuccessNonCompat())
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespDbMixedStackArgumentsGetDataByKey0().Set<FieldNameFoo>().Set<FieldNameBar>()
type respDbMixedStackArgumentsGetDataByKey0Builder struct {
    obj *respDbMixedStackArgumentsGetDataByKey0
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespDbMixedStackArgumentsGetDataByKey0().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespDbMixedStackArgumentsGetDataByKey0Builder() *respDbMixedStackArgumentsGetDataByKey0Builder {
    return &respDbMixedStackArgumentsGetDataByKey0Builder{
        obj: newRespDbMixedStackArgumentsGetDataByKey0(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespDbMixedStackArgumentsGetDataByKey0().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respDbMixedStackArgumentsGetDataByKey0Builder) Success(value []byte) *respDbMixedStackArgumentsGetDataByKey0Builder {
    x.obj.Success = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespDbMixedStackArgumentsGetDataByKey0().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respDbMixedStackArgumentsGetDataByKey0Builder) Emit() *respDbMixedStackArgumentsGetDataByKey0 {
    var objCopy respDbMixedStackArgumentsGetDataByKey0 = *x.obj
    return &objCopy
}

func (x *respDbMixedStackArgumentsGetDataByKey0) Exception() thrift.WritableException {
    return nil
}

func (x *respDbMixedStackArgumentsGetDataByKey0) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respDbMixedStackArgumentsGetDataByKey0"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField0(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 0 && wireType == thrift.Type(thrift.STRING)):  // success
            if err := x.readField0(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respDbMixedStackArgumentsGetDataByKey0) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respDbMixedStackArgumentsGetDataByKey0({")
    sb.WriteString(fmt.Sprintf("Success:%s", x.toString0()))
    sb.WriteString("})")

    return sb.String()
}
type reqDbMixedStackArgumentsGetDataByKey1 struct {
    Key string `thrift:"key,1" json:"key" db:"key"`
}
// Compile time interface enforcer
var _ thrift.Struct = &reqDbMixedStackArgumentsGetDataByKey1{}

// Deprecated: DbMixedStackArgumentsGetDataByKey1ArgsDeprecated is deprecated, since it is supposed to be internal.
type DbMixedStackArgumentsGetDataByKey1ArgsDeprecated = reqDbMixedStackArgumentsGetDataByKey1

func newReqDbMixedStackArgumentsGetDataByKey1() *reqDbMixedStackArgumentsGetDataByKey1 {
    return (&reqDbMixedStackArgumentsGetDataByKey1{}).
        SetKeyNonCompat("")
}

func (x *reqDbMixedStackArgumentsGetDataByKey1) GetKeyNonCompat() string {
    return x.Key
}

func (x *reqDbMixedStackArgumentsGetDataByKey1) GetKey() string {
    return x.Key
}

func (x *reqDbMixedStackArgumentsGetDataByKey1) SetKeyNonCompat(value string) *reqDbMixedStackArgumentsGetDataByKey1 {
    x.Key = value
    return x
}

func (x *reqDbMixedStackArgumentsGetDataByKey1) SetKey(value string) *reqDbMixedStackArgumentsGetDataByKey1 {
    x.Key = value
    return x
}

func (x *reqDbMixedStackArgumentsGetDataByKey1) writeField1(p thrift.Format) error {  // Key
    if err := p.WriteFieldBegin("key", thrift.STRING, 1); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetKeyNonCompat()
    if err := p.WriteString(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *reqDbMixedStackArgumentsGetDataByKey1) readField1(p thrift.Format) error {  // Key
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetKeyNonCompat(result)
    return nil
}

func (x *reqDbMixedStackArgumentsGetDataByKey1) toString1() string {  // Key
    return fmt.Sprintf("%v", x.GetKeyNonCompat())
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqDbMixedStackArgumentsGetDataByKey1().Set<FieldNameFoo>().Set<FieldNameBar>()
type reqDbMixedStackArgumentsGetDataByKey1Builder struct {
    obj *reqDbMixedStackArgumentsGetDataByKey1
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqDbMixedStackArgumentsGetDataByKey1().Set<FieldNameFoo>().Set<FieldNameBar>()
func newReqDbMixedStackArgumentsGetDataByKey1Builder() *reqDbMixedStackArgumentsGetDataByKey1Builder {
    return &reqDbMixedStackArgumentsGetDataByKey1Builder{
        obj: newReqDbMixedStackArgumentsGetDataByKey1(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqDbMixedStackArgumentsGetDataByKey1().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqDbMixedStackArgumentsGetDataByKey1Builder) Key(value string) *reqDbMixedStackArgumentsGetDataByKey1Builder {
    x.obj.Key = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newReqDbMixedStackArgumentsGetDataByKey1().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *reqDbMixedStackArgumentsGetDataByKey1Builder) Emit() *reqDbMixedStackArgumentsGetDataByKey1 {
    var objCopy reqDbMixedStackArgumentsGetDataByKey1 = *x.obj
    return &objCopy
}

func (x *reqDbMixedStackArgumentsGetDataByKey1) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqDbMixedStackArgumentsGetDataByKey1"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField1(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 1 && wireType == thrift.Type(thrift.STRING)):  // key
            if err := x.readField1(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *reqDbMixedStackArgumentsGetDataByKey1) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("reqDbMixedStackArgumentsGetDataByKey1({")
    sb.WriteString(fmt.Sprintf("Key:%s", x.toString1()))
    sb.WriteString("})")

    return sb.String()
}
type respDbMixedStackArgumentsGetDataByKey1 struct {
    Success []byte `thrift:"success,0,optional" json:"success,omitempty" db:"success"`
}
// Compile time interface enforcer
var _ thrift.Struct = &respDbMixedStackArgumentsGetDataByKey1{}
var _ thrift.WritableResult = &respDbMixedStackArgumentsGetDataByKey1{}

// Deprecated: DbMixedStackArgumentsGetDataByKey1ResultDeprecated is deprecated, since it is supposed to be internal.
type DbMixedStackArgumentsGetDataByKey1ResultDeprecated = respDbMixedStackArgumentsGetDataByKey1

func newRespDbMixedStackArgumentsGetDataByKey1() *respDbMixedStackArgumentsGetDataByKey1 {
    return (&respDbMixedStackArgumentsGetDataByKey1{})
}

func (x *respDbMixedStackArgumentsGetDataByKey1) GetSuccessNonCompat() []byte {
    return x.Success
}

func (x *respDbMixedStackArgumentsGetDataByKey1) GetSuccess() []byte {
    if !x.IsSetSuccess() {
        return []byte("")
    }

    return x.Success
}

func (x *respDbMixedStackArgumentsGetDataByKey1) SetSuccessNonCompat(value []byte) *respDbMixedStackArgumentsGetDataByKey1 {
    x.Success = value
    return x
}

func (x *respDbMixedStackArgumentsGetDataByKey1) SetSuccess(value []byte) *respDbMixedStackArgumentsGetDataByKey1 {
    x.Success = value
    return x
}

func (x *respDbMixedStackArgumentsGetDataByKey1) IsSetSuccess() bool {
    return x != nil && x.Success != nil
}

func (x *respDbMixedStackArgumentsGetDataByKey1) writeField0(p thrift.Format) error {  // Success
    if !x.IsSetSuccess() {
        return nil
    }

    if err := p.WriteFieldBegin("success", thrift.STRING, 0); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field begin error: ", x), err)
    }

    item := x.GetSuccessNonCompat()
    if err := p.WriteBinary(item); err != nil {
    return err
}

    if err := p.WriteFieldEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field end error: ", x), err)
    }
    return nil
}

func (x *respDbMixedStackArgumentsGetDataByKey1) readField0(p thrift.Format) error {  // Success
    result, err := p.ReadBinary()
if err != nil {
    return err
}

    x.SetSuccessNonCompat(result)
    return nil
}

func (x *respDbMixedStackArgumentsGetDataByKey1) toString0() string {  // Success
    return fmt.Sprintf("%v", x.GetSuccessNonCompat())
}


// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespDbMixedStackArgumentsGetDataByKey1().Set<FieldNameFoo>().Set<FieldNameBar>()
type respDbMixedStackArgumentsGetDataByKey1Builder struct {
    obj *respDbMixedStackArgumentsGetDataByKey1
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespDbMixedStackArgumentsGetDataByKey1().Set<FieldNameFoo>().Set<FieldNameBar>()
func newRespDbMixedStackArgumentsGetDataByKey1Builder() *respDbMixedStackArgumentsGetDataByKey1Builder {
    return &respDbMixedStackArgumentsGetDataByKey1Builder{
        obj: newRespDbMixedStackArgumentsGetDataByKey1(),
    }
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespDbMixedStackArgumentsGetDataByKey1().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respDbMixedStackArgumentsGetDataByKey1Builder) Success(value []byte) *respDbMixedStackArgumentsGetDataByKey1Builder {
    x.obj.Success = value
    return x
}

// Deprecated: Use "New" constructor and setters to build your structs.
// e.g newRespDbMixedStackArgumentsGetDataByKey1().Set<FieldNameFoo>().Set<FieldNameBar>()
func (x *respDbMixedStackArgumentsGetDataByKey1Builder) Emit() *respDbMixedStackArgumentsGetDataByKey1 {
    var objCopy respDbMixedStackArgumentsGetDataByKey1 = *x.obj
    return &objCopy
}

func (x *respDbMixedStackArgumentsGetDataByKey1) Exception() thrift.WritableException {
    return nil
}

func (x *respDbMixedStackArgumentsGetDataByKey1) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respDbMixedStackArgumentsGetDataByKey1"); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", x), err)
    }

    if err := x.writeField0(p); err != nil {
        return err
    }

    if err := p.WriteFieldStop(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", x), err)
    }

    if err := p.WriteStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", x), err)
    }
    return nil
}

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

    for {
        _, wireType, id, err := p.ReadFieldBegin()
        if err != nil {
            return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", x, id), err)
        }

        if wireType == thrift.STOP {
            break;
        }

        switch {
        case (id == 0 && wireType == thrift.Type(thrift.STRING)):  // success
            if err := x.readField0(p); err != nil {
                return err
            }
        default:
            if err := p.Skip(wireType); err != nil {
                return err
            }
        }

        if err := p.ReadFieldEnd(); err != nil {
            return err
        }
    }

    if err := p.ReadStructEnd(); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", x), err)
    }

    return nil
}

func (x *respDbMixedStackArgumentsGetDataByKey1) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respDbMixedStackArgumentsGetDataByKey1({")
    sb.WriteString(fmt.Sprintf("Success:%s", x.toString0()))
    sb.WriteString("})")

    return sb.String()
}


type DbMixedStackArgumentsProcessor struct {
    processorMap       map[string]thrift.ProcessorFunctionContext
    functionServiceMap map[string]string
    handler            DbMixedStackArguments
}
// Compile time interface enforcer
var _ thrift.ProcessorContext = &DbMixedStackArgumentsProcessor{}

func NewDbMixedStackArgumentsProcessor(handler DbMixedStackArguments) *DbMixedStackArgumentsProcessor {
    p := &DbMixedStackArgumentsProcessor{
        handler:            handler,
        processorMap:       make(map[string]thrift.ProcessorFunctionContext),
        functionServiceMap: make(map[string]string),
    }
    p.AddToProcessorMap("getDataByKey0", &procFuncDbMixedStackArgumentsGetDataByKey0{handler: handler})
    p.AddToProcessorMap("getDataByKey1", &procFuncDbMixedStackArgumentsGetDataByKey1{handler: handler})
    p.AddToFunctionServiceMap("getDataByKey0", "DbMixedStackArguments")
    p.AddToFunctionServiceMap("getDataByKey1", "DbMixedStackArguments")

    return p
}

func (p *DbMixedStackArgumentsProcessor) AddToProcessorMap(key string, processor thrift.ProcessorFunctionContext) {
    p.processorMap[key] = processor
}

func (p *DbMixedStackArgumentsProcessor) AddToFunctionServiceMap(key, service string) {
    p.functionServiceMap[key] = service
}

func (p *DbMixedStackArgumentsProcessor) GetProcessorFunctionContext(key string) (processor thrift.ProcessorFunctionContext, err error) {
    if processor, ok := p.processorMap[key]; ok {
        return processor, nil
    }
    return nil, nil
}

func (p *DbMixedStackArgumentsProcessor) ProcessorMap() map[string]thrift.ProcessorFunctionContext {
    return p.processorMap
}

func (p *DbMixedStackArgumentsProcessor) FunctionServiceMap() map[string]string {
    return p.functionServiceMap
}

func (p *DbMixedStackArgumentsProcessor) GetThriftMetadata() *metadata.ThriftMetadata {
    return GetThriftMetadataForService("module.DbMixedStackArguments")
}


type procFuncDbMixedStackArgumentsGetDataByKey0 struct {
    handler DbMixedStackArguments
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncDbMixedStackArgumentsGetDataByKey0{}

func (p *procFuncDbMixedStackArgumentsGetDataByKey0) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqDbMixedStackArgumentsGetDataByKey0()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncDbMixedStackArgumentsGetDataByKey0) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("getDataByKey0", messageType, 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
    }
    return err
}

func (p *procFuncDbMixedStackArgumentsGetDataByKey0) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    args := reqStruct.(*reqDbMixedStackArgumentsGetDataByKey0)
    result := newRespDbMixedStackArgumentsGetDataByKey0()
    retval, err := p.handler.GetDataByKey0(ctx, args.Key)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing GetDataByKey0: " + err.Error(), err)
        return x, x
    }

    result.Success = retval
    return result, nil
}


type procFuncDbMixedStackArgumentsGetDataByKey1 struct {
    handler DbMixedStackArguments
}
// Compile time interface enforcer
var _ thrift.ProcessorFunctionContext = &procFuncDbMixedStackArgumentsGetDataByKey1{}

func (p *procFuncDbMixedStackArgumentsGetDataByKey1) Read(iprot thrift.Format) (thrift.Struct, thrift.Exception) {
    args := newReqDbMixedStackArgumentsGetDataByKey1()
    if err := args.Read(iprot); err != nil {
        return nil, err
    }
    iprot.ReadMessageEnd()
    return args, nil
}

func (p *procFuncDbMixedStackArgumentsGetDataByKey1) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch result.(type) {
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("getDataByKey1", messageType, 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
    }
    return err
}

func (p *procFuncDbMixedStackArgumentsGetDataByKey1) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    args := reqStruct.(*reqDbMixedStackArgumentsGetDataByKey1)
    result := newRespDbMixedStackArgumentsGetDataByKey1()
    retval, err := p.handler.GetDataByKey1(ctx, args.Key)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing GetDataByKey1: " + err.Error(), err)
        return x, x
    }

    result.Success = retval
    return result, nil
}