pingpong

Documentation

Overview

Package pingpong is generated code used to make or handle TChannel calls using Thrift.

Index

• Variables
• func NewTChanPingPongInheritedClient(thriftService string, client thrift.TChanClient) *tchanPingPongClient
• func NewTChanPingPongServer(handler TChanPingPong) thrift.TChanServer
• type MockTChanPingPong
  • func (_m *MockTChanPingPong) Ping(ctx thrift.Context, request *Ping) (*Pong, error)
• type Ping
  • func NewPing() *Ping
  • func (p *Ping) GetKey() string
  • func (p *Ping) Read(iprot thrift.TProtocol) error
  • func (p *Ping) String() string
  • func (p *Ping) Write(oprot thrift.TProtocol) error
• type PingError
  • func NewPingError() *PingError
  • func (p *PingError) Error() string
  • func (p *PingError) Read(iprot thrift.TProtocol) error
  • func (p *PingError) String() string
  • func (p *PingError) Write(oprot thrift.TProtocol) error
• type PingPong
• type PingPongClient
  • func NewPingPongClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *PingPongClient
  • func NewPingPongClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *PingPongClient
  • func (p *PingPongClient) Ping(request *Ping) (r *Pong, err error)
• type PingPongPingArgs
  • func NewPingPongPingArgs() *PingPongPingArgs
  • func (p *PingPongPingArgs) GetRequest() *Ping
  • func (p *PingPongPingArgs) IsSetRequest() bool
  • func (p *PingPongPingArgs) Read(iprot thrift.TProtocol) error
  • func (p *PingPongPingArgs) String() string
  • func (p *PingPongPingArgs) Write(oprot thrift.TProtocol) error
• type PingPongPingResult
  • func NewPingPongPingResult() *PingPongPingResult
  • func (p *PingPongPingResult) GetPingError() *PingError
  • func (p *PingPongPingResult) GetSuccess() *Pong
  • func (p *PingPongPingResult) IsSetPingError() bool
  • func (p *PingPongPingResult) IsSetSuccess() bool
  • func (p *PingPongPingResult) Read(iprot thrift.TProtocol) error
  • func (p *PingPongPingResult) String() string
  • func (p *PingPongPingResult) Write(oprot thrift.TProtocol) error
• type PingPongProcessor
  • func NewPingPongProcessor(handler PingPong) *PingPongProcessor
  • func (p *PingPongProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction)
  • func (p *PingPongProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool)
  • func (p *PingPongProcessor) Process(iprot, oprot thrift.TProtocol) (success bool, err thrift.TException)
  • func (p *PingPongProcessor) ProcessorMap() map[string]thrift.TProcessorFunction
• type Pong
  • func NewPong() *Pong
  • func (p *Pong) GetSource() string
  • func (p *Pong) Read(iprot thrift.TProtocol) error
  • func (p *Pong) String() string
  • func (p *Pong) Write(oprot thrift.TProtocol) error
• type TChanPingPong
  • func NewTChanPingPongClient(client thrift.TChanClient) TChanPingPong

Variables

var GoUnusedProtection__ int

Functions

func NewTChanPingPongInheritedClient

func NewTChanPingPongInheritedClient(thriftService string, client thrift.TChanClient) *tchanPingPongClient

func NewTChanPingPongServer

func NewTChanPingPongServer(handler TChanPingPong) thrift.TChanServer

NewTChanPingPongServer wraps a handler for TChanPingPong so it can be registered with a thrift.Server.

Types

type MockTChanPingPong

type MockTChanPingPong struct {
	mock.Mock
}

func (*MockTChanPingPong) Ping

func (_m *MockTChanPingPong) Ping(ctx thrift.Context, request *Ping) (*Pong, error)

Ping provides a mock function with given fields: ctx, request

type Ping

type Ping struct {
	Key string `thrift:"key,1,required" json:"key"`
}

Attributes:

• Key

var PingPongPingArgs_Request_DEFAULT *Ping

func NewPing

func NewPing() *Ping

func (*Ping) GetKey

func (p *Ping) GetKey() string

func (*Ping) Read

func (p *Ping) Read(iprot thrift.TProtocol) error

func (*Ping) String

func (p *Ping) String() string

func (*Ping) Write

func (p *Ping) Write(oprot thrift.TProtocol) error

type PingError

type PingError struct {
}

var PingPongPingResult_PingError_DEFAULT *PingError

func NewPingError

func NewPingError() *PingError

func (*PingError) Error

func (p *PingError) Error() string

func (*PingError) Read

func (p *PingError) Read(iprot thrift.TProtocol) error

func (*PingError) String

func (p *PingError) String() string

func (*PingError) Write

func (p *PingError) Write(oprot thrift.TProtocol) error

type PingPong

type PingPong interface {
	// Parameters:
	//  - Request
	Ping(request *Ping) (r *Pong, err error)
}

type PingPongClient

type PingPongClient struct {
	Transport       thrift.TTransport
	ProtocolFactory thrift.TProtocolFactory
	InputProtocol   thrift.TProtocol
	OutputProtocol  thrift.TProtocol
	SeqId           int32
}

func NewPingPongClientFactory

func NewPingPongClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *PingPongClient

func NewPingPongClientProtocol

func NewPingPongClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *PingPongClient

func (*PingPongClient) Ping

func (p *PingPongClient) Ping(request *Ping) (r *Pong, err error)

Parameters:

• Request

type PingPongPingArgs

type PingPongPingArgs struct {
	Request *Ping `thrift:"request,1" json:"request"`
}

Attributes:

• Request

func NewPingPongPingArgs

func NewPingPongPingArgs() *PingPongPingArgs

func (*PingPongPingArgs) GetRequest

func (p *PingPongPingArgs) GetRequest() *Ping

func (*PingPongPingArgs) IsSetRequest

func (p *PingPongPingArgs) IsSetRequest() bool

func (*PingPongPingArgs) Read

func (p *PingPongPingArgs) Read(iprot thrift.TProtocol) error

func (*PingPongPingArgs) String

func (p *PingPongPingArgs) String() string

func (*PingPongPingArgs) Write

func (p *PingPongPingArgs) Write(oprot thrift.TProtocol) error

type PingPongPingResult

type PingPongPingResult struct {
	Success   *Pong      `thrift:"success,0" json:"success,omitempty"`
	PingError *PingError `thrift:"pingError,1" json:"pingError,omitempty"`
}

Attributes:

• Success
• PingError

func NewPingPongPingResult

func NewPingPongPingResult() *PingPongPingResult

func (*PingPongPingResult) GetPingError

func (p *PingPongPingResult) GetPingError() *PingError

func (*PingPongPingResult) GetSuccess

func (p *PingPongPingResult) GetSuccess() *Pong

func (*PingPongPingResult) IsSetPingError

func (p *PingPongPingResult) IsSetPingError() bool

func (*PingPongPingResult) IsSetSuccess

func (p *PingPongPingResult) IsSetSuccess() bool

func (*PingPongPingResult) Read

func (p *PingPongPingResult) Read(iprot thrift.TProtocol) error

func (*PingPongPingResult) String

func (p *PingPongPingResult) String() string

func (*PingPongPingResult) Write

func (p *PingPongPingResult) Write(oprot thrift.TProtocol) error

type PingPongProcessor

type PingPongProcessor struct {
	// contains filtered or unexported fields
}

func NewPingPongProcessor

func NewPingPongProcessor(handler PingPong) *PingPongProcessor

func (*PingPongProcessor) AddToProcessorMap

func (p *PingPongProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction)

func (*PingPongProcessor) GetProcessorFunction

func (p *PingPongProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool)

func (*PingPongProcessor) Process

func (p *PingPongProcessor) Process(iprot, oprot thrift.TProtocol) (success bool, err thrift.TException)

func (*PingPongProcessor) ProcessorMap

func (p *PingPongProcessor) ProcessorMap() map[string]thrift.TProcessorFunction

type Pong

type Pong struct {
	Source string `thrift:"source,1,required" json:"source"`
}

Attributes:

• Source

var PingPongPingResult_Success_DEFAULT *Pong

func NewPong

func NewPong() *Pong

func (*Pong) GetSource

func (p *Pong) GetSource() string

func (*Pong) Read

func (p *Pong) Read(iprot thrift.TProtocol) error

func (*Pong) String

func (p *Pong) String() string

func (*Pong) Write

func (p *Pong) Write(oprot thrift.TProtocol) error

type TChanPingPong

type TChanPingPong interface {
	Ping(ctx thrift.Context, request *Ping) (*Pong, error)
}

TChanPingPong is the interface that defines the server handler and client interface.

func NewTChanPingPongClient

func NewTChanPingPongClient(client thrift.TChanClient) TChanPingPong

NewTChanPingPongClient creates a client that can be used to make remote calls.