// @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 Raiser interface {
    DoBland(ctx context.Context) (error)
    DoRaise(ctx context.Context) (error)
    Get200(ctx context.Context) (string, error)
    Get500(ctx context.Context) (string, error)
}

type RaiserChannelClientInterface interface {
    thrift.ClientInterface
    Raiser
}

type RaiserClientInterface interface {
    thrift.ClientInterface
    DoBland() (error)
    DoRaise() (error)
    Get200() (string, error)
    Get500() (string, error)
}

type RaiserContextClientInterface interface {
    RaiserClientInterface
    DoBlandContext(ctx context.Context) (error)
    DoRaiseContext(ctx context.Context) (error)
    Get200Context(ctx context.Context) (string, error)
    Get500Context(ctx context.Context) (string, error)
}

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

func NewRaiserChannelClient(channel thrift.RequestChannel) *RaiserChannelClient {
    return &RaiserChannelClient{
        ch: channel,
    }
}

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

type RaiserClient struct {
    chClient *RaiserChannelClient
    Mu       sync.Mutex
}
// Compile time interface enforcer
var _ RaiserClientInterface = &RaiserClient{}
var _ RaiserContextClientInterface = &RaiserClient{}

func NewRaiserClient(prot thrift.Protocol) *RaiserClient {
    return &RaiserClient{
        chClient: NewRaiserChannelClient(
            thrift.NewSerialChannel(prot),
        ),
    }
}

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

func (c *RaiserChannelClient) DoBland(ctx context.Context) (error) {
    in := &reqRaiserDoBland{
    }
    out := newRespRaiserDoBland()
    err := c.ch.Call(ctx, "doBland", in, out)
    if err != nil {
        return err
    }
    return nil
}

func (c *RaiserClient) DoBland() (error) {
    return c.chClient.DoBland(context.Background())
}

func (c *RaiserClient) DoBlandContext(ctx context.Context) (error) {
    return c.chClient.DoBland(ctx)
}

func (c *RaiserChannelClient) DoRaise(ctx context.Context) (error) {
    in := &reqRaiserDoRaise{
    }
    out := newRespRaiserDoRaise()
    err := c.ch.Call(ctx, "doRaise", in, out)
    if err != nil {
        return err
    } else if out.B != nil {
        return out.B
    } else if out.F != nil {
        return out.F
    } else if out.S != nil {
        return out.S
    }
    return nil
}

func (c *RaiserClient) DoRaise() (error) {
    return c.chClient.DoRaise(context.Background())
}

func (c *RaiserClient) DoRaiseContext(ctx context.Context) (error) {
    return c.chClient.DoRaise(ctx)
}

func (c *RaiserChannelClient) Get200(ctx context.Context) (string, error) {
    in := &reqRaiserGet200{
    }
    out := newRespRaiserGet200()
    err := c.ch.Call(ctx, "get200", in, out)
    if err != nil {
        return "", err
    }
    return out.GetSuccess(), nil
}

func (c *RaiserClient) Get200() (string, error) {
    return c.chClient.Get200(context.Background())
}

func (c *RaiserClient) Get200Context(ctx context.Context) (string, error) {
    return c.chClient.Get200(ctx)
}

func (c *RaiserChannelClient) Get500(ctx context.Context) (string, error) {
    in := &reqRaiserGet500{
    }
    out := newRespRaiserGet500()
    err := c.ch.Call(ctx, "get500", in, out)
    if err != nil {
        return "", err
    } else if out.F != nil {
        return "", out.F
    } else if out.B != nil {
        return "", out.B
    } else if out.S != nil {
        return "", out.S
    }
    return out.GetSuccess(), nil
}

func (c *RaiserClient) Get500() (string, error) {
    return c.chClient.Get500(context.Background())
}

func (c *RaiserClient) Get500Context(ctx context.Context) (string, error) {
    return c.chClient.Get500(ctx)
}

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

// Deprecated: RaiserDoBlandArgsDeprecated is deprecated, since it is supposed to be internal.
type RaiserDoBlandArgsDeprecated = reqRaiserDoBland

func newReqRaiserDoBland() *reqRaiserDoBland {
    return (&reqRaiserDoBland{})
}


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

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

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

func (x *reqRaiserDoBland) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqRaiserDoBland"); 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 *reqRaiserDoBland) 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 *reqRaiserDoBland) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

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

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

// Deprecated: RaiserDoBlandResultDeprecated is deprecated, since it is supposed to be internal.
type RaiserDoBlandResultDeprecated = respRaiserDoBland

func newRespRaiserDoBland() *respRaiserDoBland {
    return (&respRaiserDoBland{})
}


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

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

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

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

func (x *respRaiserDoBland) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respRaiserDoBland"); 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 *respRaiserDoBland) 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 *respRaiserDoBland) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

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

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

// Deprecated: RaiserDoRaiseArgsDeprecated is deprecated, since it is supposed to be internal.
type RaiserDoRaiseArgsDeprecated = reqRaiserDoRaise

func newReqRaiserDoRaise() *reqRaiserDoRaise {
    return (&reqRaiserDoRaise{})
}


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

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

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

func (x *reqRaiserDoRaise) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqRaiserDoRaise"); 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 *reqRaiserDoRaise) 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 *reqRaiserDoRaise) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

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

    return sb.String()
}
type respRaiserDoRaise struct {
    B *Banal `thrift:"b,1,optional" json:"b,omitempty" db:"b"`
    F *Fiery `thrift:"f,2,optional" json:"f,omitempty" db:"f"`
    S *Serious `thrift:"s,3,optional" json:"s,omitempty" db:"s"`
}
// Compile time interface enforcer
var _ thrift.Struct = &respRaiserDoRaise{}
var _ thrift.WritableResult = &respRaiserDoRaise{}

// Deprecated: RaiserDoRaiseResultDeprecated is deprecated, since it is supposed to be internal.
type RaiserDoRaiseResultDeprecated = respRaiserDoRaise

func newRespRaiserDoRaise() *respRaiserDoRaise {
    return (&respRaiserDoRaise{})
}

func (x *respRaiserDoRaise) GetBNonCompat() *Banal {
    return x.B
}

func (x *respRaiserDoRaise) GetB() *Banal {
    if !x.IsSetB() {
        return nil
    }

    return x.B
}

func (x *respRaiserDoRaise) GetFNonCompat() *Fiery {
    return x.F
}

func (x *respRaiserDoRaise) GetF() *Fiery {
    if !x.IsSetF() {
        return nil
    }

    return x.F
}

func (x *respRaiserDoRaise) GetSNonCompat() *Serious {
    return x.S
}

func (x *respRaiserDoRaise) GetS() *Serious {
    if !x.IsSetS() {
        return nil
    }

    return x.S
}

func (x *respRaiserDoRaise) SetBNonCompat(value Banal) *respRaiserDoRaise {
    x.B = &value
    return x
}

func (x *respRaiserDoRaise) SetB(value *Banal) *respRaiserDoRaise {
    x.B = value
    return x
}

func (x *respRaiserDoRaise) SetFNonCompat(value Fiery) *respRaiserDoRaise {
    x.F = &value
    return x
}

func (x *respRaiserDoRaise) SetF(value *Fiery) *respRaiserDoRaise {
    x.F = value
    return x
}

func (x *respRaiserDoRaise) SetSNonCompat(value Serious) *respRaiserDoRaise {
    x.S = &value
    return x
}

func (x *respRaiserDoRaise) SetS(value *Serious) *respRaiserDoRaise {
    x.S = value
    return x
}

func (x *respRaiserDoRaise) IsSetB() bool {
    return x != nil && x.B != nil
}

func (x *respRaiserDoRaise) IsSetF() bool {
    return x != nil && x.F != nil
}

func (x *respRaiserDoRaise) IsSetS() bool {
    return x != nil && x.S != nil
}

func (x *respRaiserDoRaise) writeField1(p thrift.Format) error {  // B
    if !x.IsSetB() {
        return nil
    }

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

    item := x.GetBNonCompat()
    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 *respRaiserDoRaise) writeField2(p thrift.Format) error {  // F
    if !x.IsSetF() {
        return nil
    }

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

    item := x.GetFNonCompat()
    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 *respRaiserDoRaise) writeField3(p thrift.Format) error {  // S
    if !x.IsSetS() {
        return nil
    }

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

    item := x.GetSNonCompat()
    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 *respRaiserDoRaise) readField1(p thrift.Format) error {  // B
    result := *NewBanal()
err := result.Read(p)
if err != nil {
    return err
}

    x.SetBNonCompat(result)
    return nil
}

func (x *respRaiserDoRaise) readField2(p thrift.Format) error {  // F
    result := *NewFiery()
err := result.Read(p)
if err != nil {
    return err
}

    x.SetFNonCompat(result)
    return nil
}

func (x *respRaiserDoRaise) readField3(p thrift.Format) error {  // S
    result := *NewSerious()
err := result.Read(p)
if err != nil {
    return err
}

    x.SetSNonCompat(result)
    return nil
}

func (x *respRaiserDoRaise) toString1() string {  // B
    return fmt.Sprintf("%v", x.GetBNonCompat())
}

func (x *respRaiserDoRaise) toString2() string {  // F
    return fmt.Sprintf("%v", x.GetFNonCompat())
}

func (x *respRaiserDoRaise) toString3() string {  // S
    return fmt.Sprintf("%v", x.GetSNonCompat())
}

// Deprecated: Use newRespRaiserDoRaise().GetB() instead.
func (x *respRaiserDoRaise) DefaultGetB() *Banal {
    if !x.IsSetB() {
        return NewBanal()
    }
    return x.B
}

// Deprecated: Use newRespRaiserDoRaise().GetF() instead.
func (x *respRaiserDoRaise) DefaultGetF() *Fiery {
    if !x.IsSetF() {
        return NewFiery()
    }
    return x.F
}

// Deprecated: Use newRespRaiserDoRaise().GetS() instead.
func (x *respRaiserDoRaise) DefaultGetS() *Serious {
    if !x.IsSetS() {
        return NewSerious()
    }
    return x.S
}


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

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

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

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

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

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

func (x *respRaiserDoRaise) Exception() thrift.WritableException {
    if x.B != nil {
        return x.B
    }
    if x.F != nil {
        return x.F
    }
    if x.S != nil {
        return x.S
    }
    return nil
}

func (x *respRaiserDoRaise) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respRaiserDoRaise"); 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 := x.writeField3(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 *respRaiserDoRaise) 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.STRUCT)):  // b
            if err := x.readField1(p); err != nil {
                return err
            }
        case (id == 2 && wireType == thrift.Type(thrift.STRUCT)):  // f
            if err := x.readField2(p); err != nil {
                return err
            }
        case (id == 3 && wireType == thrift.Type(thrift.STRUCT)):  // s
            if err := x.readField3(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 *respRaiserDoRaise) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respRaiserDoRaise({")
    sb.WriteString(fmt.Sprintf("B:%s ", x.toString1()))
    sb.WriteString(fmt.Sprintf("F:%s ", x.toString2()))
    sb.WriteString(fmt.Sprintf("S:%s", x.toString3()))
    sb.WriteString("})")

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

// Deprecated: RaiserGet200ArgsDeprecated is deprecated, since it is supposed to be internal.
type RaiserGet200ArgsDeprecated = reqRaiserGet200

func newReqRaiserGet200() *reqRaiserGet200 {
    return (&reqRaiserGet200{})
}


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

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

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

func (x *reqRaiserGet200) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqRaiserGet200"); 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 *reqRaiserGet200) 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 *reqRaiserGet200) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

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

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

// Deprecated: RaiserGet200ResultDeprecated is deprecated, since it is supposed to be internal.
type RaiserGet200ResultDeprecated = respRaiserGet200

func newRespRaiserGet200() *respRaiserGet200 {
    return (&respRaiserGet200{})
}

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

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

    return *x.Success
}

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

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

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

func (x *respRaiserGet200) 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 *respRaiserGet200) readField0(p thrift.Format) error {  // Success
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetSuccessNonCompat(result)
    return nil
}

func (x *respRaiserGet200) 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 newRespRaiserGet200().Set<FieldNameFoo>().Set<FieldNameBar>()
type respRaiserGet200Builder struct {
    obj *respRaiserGet200
}

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

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

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

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

func (x *respRaiserGet200) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respRaiserGet200"); 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 *respRaiserGet200) 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 *respRaiserGet200) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

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

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

// Deprecated: RaiserGet500ArgsDeprecated is deprecated, since it is supposed to be internal.
type RaiserGet500ArgsDeprecated = reqRaiserGet500

func newReqRaiserGet500() *reqRaiserGet500 {
    return (&reqRaiserGet500{})
}


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

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

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

func (x *reqRaiserGet500) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("reqRaiserGet500"); 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 *reqRaiserGet500) 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 *reqRaiserGet500) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

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

    return sb.String()
}
type respRaiserGet500 struct {
    Success *string `thrift:"success,0,optional" json:"success,omitempty" db:"success"`
    F *Fiery `thrift:"f,1,optional" json:"f,omitempty" db:"f"`
    B *Banal `thrift:"b,2,optional" json:"b,omitempty" db:"b"`
    S *Serious `thrift:"s,3,optional" json:"s,omitempty" db:"s"`
}
// Compile time interface enforcer
var _ thrift.Struct = &respRaiserGet500{}
var _ thrift.WritableResult = &respRaiserGet500{}

// Deprecated: RaiserGet500ResultDeprecated is deprecated, since it is supposed to be internal.
type RaiserGet500ResultDeprecated = respRaiserGet500

func newRespRaiserGet500() *respRaiserGet500 {
    return (&respRaiserGet500{})
}

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

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

    return *x.Success
}

func (x *respRaiserGet500) GetFNonCompat() *Fiery {
    return x.F
}

func (x *respRaiserGet500) GetF() *Fiery {
    if !x.IsSetF() {
        return nil
    }

    return x.F
}

func (x *respRaiserGet500) GetBNonCompat() *Banal {
    return x.B
}

func (x *respRaiserGet500) GetB() *Banal {
    if !x.IsSetB() {
        return nil
    }

    return x.B
}

func (x *respRaiserGet500) GetSNonCompat() *Serious {
    return x.S
}

func (x *respRaiserGet500) GetS() *Serious {
    if !x.IsSetS() {
        return nil
    }

    return x.S
}

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

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

func (x *respRaiserGet500) SetFNonCompat(value Fiery) *respRaiserGet500 {
    x.F = &value
    return x
}

func (x *respRaiserGet500) SetF(value *Fiery) *respRaiserGet500 {
    x.F = value
    return x
}

func (x *respRaiserGet500) SetBNonCompat(value Banal) *respRaiserGet500 {
    x.B = &value
    return x
}

func (x *respRaiserGet500) SetB(value *Banal) *respRaiserGet500 {
    x.B = value
    return x
}

func (x *respRaiserGet500) SetSNonCompat(value Serious) *respRaiserGet500 {
    x.S = &value
    return x
}

func (x *respRaiserGet500) SetS(value *Serious) *respRaiserGet500 {
    x.S = value
    return x
}

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

func (x *respRaiserGet500) IsSetF() bool {
    return x != nil && x.F != nil
}

func (x *respRaiserGet500) IsSetB() bool {
    return x != nil && x.B != nil
}

func (x *respRaiserGet500) IsSetS() bool {
    return x != nil && x.S != nil
}

func (x *respRaiserGet500) 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 *respRaiserGet500) writeField1(p thrift.Format) error {  // F
    if !x.IsSetF() {
        return nil
    }

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

    item := x.GetFNonCompat()
    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 *respRaiserGet500) writeField2(p thrift.Format) error {  // B
    if !x.IsSetB() {
        return nil
    }

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

    item := x.GetBNonCompat()
    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 *respRaiserGet500) writeField3(p thrift.Format) error {  // S
    if !x.IsSetS() {
        return nil
    }

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

    item := x.GetSNonCompat()
    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 *respRaiserGet500) readField0(p thrift.Format) error {  // Success
    result, err := p.ReadString()
if err != nil {
    return err
}

    x.SetSuccessNonCompat(result)
    return nil
}

func (x *respRaiserGet500) readField1(p thrift.Format) error {  // F
    result := *NewFiery()
err := result.Read(p)
if err != nil {
    return err
}

    x.SetFNonCompat(result)
    return nil
}

func (x *respRaiserGet500) readField2(p thrift.Format) error {  // B
    result := *NewBanal()
err := result.Read(p)
if err != nil {
    return err
}

    x.SetBNonCompat(result)
    return nil
}

func (x *respRaiserGet500) readField3(p thrift.Format) error {  // S
    result := *NewSerious()
err := result.Read(p)
if err != nil {
    return err
}

    x.SetSNonCompat(result)
    return nil
}

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

func (x *respRaiserGet500) toString1() string {  // F
    return fmt.Sprintf("%v", x.GetFNonCompat())
}

func (x *respRaiserGet500) toString2() string {  // B
    return fmt.Sprintf("%v", x.GetBNonCompat())
}

func (x *respRaiserGet500) toString3() string {  // S
    return fmt.Sprintf("%v", x.GetSNonCompat())
}


// Deprecated: Use newRespRaiserGet500().GetF() instead.
func (x *respRaiserGet500) DefaultGetF() *Fiery {
    if !x.IsSetF() {
        return NewFiery()
    }
    return x.F
}

// Deprecated: Use newRespRaiserGet500().GetB() instead.
func (x *respRaiserGet500) DefaultGetB() *Banal {
    if !x.IsSetB() {
        return NewBanal()
    }
    return x.B
}

// Deprecated: Use newRespRaiserGet500().GetS() instead.
func (x *respRaiserGet500) DefaultGetS() *Serious {
    if !x.IsSetS() {
        return NewSerious()
    }
    return x.S
}


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

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

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

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

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

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

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

func (x *respRaiserGet500) Exception() thrift.WritableException {
    if x.F != nil {
        return x.F
    }
    if x.B != nil {
        return x.B
    }
    if x.S != nil {
        return x.S
    }
    return nil
}

func (x *respRaiserGet500) Write(p thrift.Format) error {
    if err := p.WriteStructBegin("respRaiserGet500"); 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 := x.writeField1(p); err != nil {
        return err
    }

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

    if err := x.writeField3(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 *respRaiserGet500) 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
            }
        case (id == 1 && wireType == thrift.Type(thrift.STRUCT)):  // f
            if err := x.readField1(p); err != nil {
                return err
            }
        case (id == 2 && wireType == thrift.Type(thrift.STRUCT)):  // b
            if err := x.readField2(p); err != nil {
                return err
            }
        case (id == 3 && wireType == thrift.Type(thrift.STRUCT)):  // s
            if err := x.readField3(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 *respRaiserGet500) String() string {
    if x == nil {
        return "<nil>"
    }

    var sb strings.Builder

    sb.WriteString("respRaiserGet500({")
    sb.WriteString(fmt.Sprintf("Success:%s ", x.toString0()))
    sb.WriteString(fmt.Sprintf("F:%s ", x.toString1()))
    sb.WriteString(fmt.Sprintf("B:%s ", x.toString2()))
    sb.WriteString(fmt.Sprintf("S:%s", x.toString3()))
    sb.WriteString("})")

    return sb.String()
}


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

func NewRaiserProcessor(handler Raiser) *RaiserProcessor {
    p := &RaiserProcessor{
        handler:            handler,
        processorMap:       make(map[string]thrift.ProcessorFunctionContext),
        functionServiceMap: make(map[string]string),
    }
    p.AddToProcessorMap("doBland", &procFuncRaiserDoBland{handler: handler})
    p.AddToProcessorMap("doRaise", &procFuncRaiserDoRaise{handler: handler})
    p.AddToProcessorMap("get200", &procFuncRaiserGet200{handler: handler})
    p.AddToProcessorMap("get500", &procFuncRaiserGet500{handler: handler})
    p.AddToFunctionServiceMap("doBland", "Raiser")
    p.AddToFunctionServiceMap("doRaise", "Raiser")
    p.AddToFunctionServiceMap("get200", "Raiser")
    p.AddToFunctionServiceMap("get500", "Raiser")

    return p
}

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

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

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

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

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

func (p *RaiserProcessor) GetThriftMetadata() *metadata.ThriftMetadata {
    return GetThriftMetadataForService("module.Raiser")
}


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

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

func (p *procFuncRaiserDoBland) 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("doBland", 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 *procFuncRaiserDoBland) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    result := newRespRaiserDoBland()
    err := p.handler.DoBland(ctx)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing DoBland: " + err.Error(), err)
        return x, x
    }

    return result, nil
}


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

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

func (p *procFuncRaiserDoRaise) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch v := result.(type) {
    case *Banal:
        result = &respRaiserDoRaise{
            B: v,
        }
    case *Fiery:
        result = &respRaiserDoRaise{
            F: v,
        }
    case *Serious:
        result = &respRaiserDoRaise{
            S: v,
        }
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("doRaise", 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 *procFuncRaiserDoRaise) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    result := newRespRaiserDoRaise()
    err := p.handler.DoRaise(ctx)
    if err != nil {
        switch v := err.(type) {
        case *Banal:
            result.B = v
            return result, nil
        case *Fiery:
            result.F = v
            return result, nil
        case *Serious:
            result.S = v
            return result, nil
        default:
            x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing DoRaise: " + err.Error(), err)
            return x, x
        }
    }

    return result, nil
}


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

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

func (p *procFuncRaiserGet200) 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("get200", 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 *procFuncRaiserGet200) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    result := newRespRaiserGet200()
    retval, err := p.handler.Get200(ctx)
    if err != nil {
        x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing Get200: " + err.Error(), err)
        return x, x
    }

    result.Success = &retval
    return result, nil
}


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

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

func (p *procFuncRaiserGet500) Write(seqId int32, result thrift.WritableStruct, oprot thrift.Format) (err thrift.Exception) {
    var err2 error
    messageType := thrift.REPLY
    switch v := result.(type) {
    case *Fiery:
        result = &respRaiserGet500{
            F: v,
        }
    case *Banal:
        result = &respRaiserGet500{
            B: v,
        }
    case *Serious:
        result = &respRaiserGet500{
            S: v,
        }
    case thrift.ApplicationException:
        messageType = thrift.EXCEPTION
    }

    if err2 = oprot.WriteMessageBegin("get500", 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 *procFuncRaiserGet500) RunContext(ctx context.Context, reqStruct thrift.Struct) (thrift.WritableStruct, thrift.ApplicationException) {
    result := newRespRaiserGet500()
    retval, err := p.handler.Get500(ctx)
    if err != nil {
        switch v := err.(type) {
        case *Fiery:
            result.F = v
            return result, nil
        case *Banal:
            result.B = v
            return result, nil
        case *Serious:
            result.S = v
            return result, nil
        default:
            x := thrift.NewApplicationExceptionCause(thrift.INTERNAL_ERROR, "Internal error processing Get500: " + err.Error(), err)
            return x, x
        }
    }

    result.Success = &retval
    return result, nil
}