module

package
v0.0.0-...-7428086 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 23, 2023 License: Apache-2.0 Imports: 5 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var GoUnusedProtection__ int

Functions

This section is empty.

Types

type MyLeaf 

type MyLeaf interface {
	MyNode

	DoLeaf() (err error)
}

type MyLeafChannelClient 

type MyLeafChannelClient struct {
	*MyNodeChannelClient
}

func NewMyLeafChannelClient 

func NewMyLeafChannelClient(channel thrift.RequestChannel) *MyLeafChannelClient

func (*MyLeafChannelClient) Close 

func (c *MyLeafChannelClient) Close() error

func (*MyLeafChannelClient) DoLeaf 

func (p *MyLeafChannelClient) DoLeaf(ctx context.Context) (err error)

func (*MyLeafChannelClient) IsOpen 

func (c *MyLeafChannelClient) IsOpen() bool

func (*MyLeafChannelClient) Open 

func (c *MyLeafChannelClient) Open() error

type MyLeafClient 

type MyLeafClient struct {
	MyLeafClientInterface
	*MyNodeClient
}

func NewMyLeafClient 

func NewMyLeafClient(t thrift.Transport, iprot thrift.Protocol, oprot thrift.Protocol) *MyLeafClient

func NewMyLeafClientFactory 

func NewMyLeafClientFactory(t thrift.Transport, f thrift.ProtocolFactory) *MyLeafClient

func NewMyLeafClientProtocol 

func NewMyLeafClientProtocol(prot thrift.Protocol) *MyLeafClient

func (*MyLeafClient) Close 

func (client *MyLeafClient) Close() error

func (*MyLeafClient) DoLeaf 

func (p *MyLeafClient) DoLeaf() (err error)

func (*MyLeafClient) IsOpen 

func (client *MyLeafClient) IsOpen() bool

func (*MyLeafClient) Open 

func (client *MyLeafClient) Open() error

type MyLeafClientInterface 

type MyLeafClientInterface interface {
	thrift.ClientInterface
	DoLeaf() (err error)
}

type MyLeafDoLeafArgs 

type MyLeafDoLeafArgs struct {
	thrift.IRequest
}

func NewMyLeafDoLeafArgs 

func NewMyLeafDoLeafArgs() *MyLeafDoLeafArgs

func (*MyLeafDoLeafArgs) Read 

func (p *MyLeafDoLeafArgs) Read(iprot thrift.Protocol) error

func (*MyLeafDoLeafArgs) String 

func (p *MyLeafDoLeafArgs) String() string

func (*MyLeafDoLeafArgs) Write 

func (p *MyLeafDoLeafArgs) Write(oprot thrift.Protocol) error

type MyLeafDoLeafArgsBuilder 

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

func NewMyLeafDoLeafArgsBuilder 

func NewMyLeafDoLeafArgsBuilder() *MyLeafDoLeafArgsBuilder

func (MyLeafDoLeafArgsBuilder) Emit 

func (p MyLeafDoLeafArgsBuilder) Emit() *MyLeafDoLeafArgs

type MyLeafDoLeafResult 

type MyLeafDoLeafResult struct {
	thrift.IResponse
}

func NewMyLeafDoLeafResult 

func NewMyLeafDoLeafResult() *MyLeafDoLeafResult

func (*MyLeafDoLeafResult) Exception 

func (p *MyLeafDoLeafResult) Exception() thrift.WritableException

func (*MyLeafDoLeafResult) Read 

func (p *MyLeafDoLeafResult) Read(iprot thrift.Protocol) error

func (*MyLeafDoLeafResult) String 

func (p *MyLeafDoLeafResult) String() string

func (*MyLeafDoLeafResult) Write 

func (p *MyLeafDoLeafResult) Write(oprot thrift.Protocol) error

type MyLeafDoLeafResultBuilder 

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

func NewMyLeafDoLeafResultBuilder 

func NewMyLeafDoLeafResultBuilder() *MyLeafDoLeafResultBuilder

func (MyLeafDoLeafResultBuilder) Emit 

func (p MyLeafDoLeafResultBuilder) Emit() *MyLeafDoLeafResult

type MyLeafProcessor 

type MyLeafProcessor struct {
	*MyNodeProcessor
}

func NewMyLeafProcessor 

func NewMyLeafProcessor(handler MyLeaf) *MyLeafProcessor

type MyLeafThreadsafeClient 

type MyLeafThreadsafeClient struct {
	MyLeafClientInterface
	*MyNodeThreadsafeClient
}

func NewMyLeafThreadsafeClient 

func NewMyLeafThreadsafeClient(t thrift.Transport, iprot thrift.Protocol, oprot thrift.Protocol) *MyLeafThreadsafeClient

func NewMyLeafThreadsafeClientFactory 

func NewMyLeafThreadsafeClientFactory(t thrift.Transport, f thrift.ProtocolFactory) *MyLeafThreadsafeClient

func NewMyLeafThreadsafeClientProtocol 

func NewMyLeafThreadsafeClientProtocol(prot thrift.Protocol) *MyLeafThreadsafeClient

func (*MyLeafThreadsafeClient) Close 

func (client *MyLeafThreadsafeClient) Close() error

func (*MyLeafThreadsafeClient) DoLeaf 

func (p *MyLeafThreadsafeClient) DoLeaf() (err error)

func (*MyLeafThreadsafeClient) IsOpen 

func (client *MyLeafThreadsafeClient) IsOpen() bool

func (*MyLeafThreadsafeClient) Open 

func (client *MyLeafThreadsafeClient) Open() error

type MyNode 

type MyNode interface {
	MyRoot

	DoMid() (err error)
}

type MyNodeChannelClient 

type MyNodeChannelClient struct {
	*MyRootChannelClient
}

func NewMyNodeChannelClient 

func NewMyNodeChannelClient(channel thrift.RequestChannel) *MyNodeChannelClient

func (*MyNodeChannelClient) Close 

func (c *MyNodeChannelClient) Close() error

func (*MyNodeChannelClient) DoMid 

func (p *MyNodeChannelClient) DoMid(ctx context.Context) (err error)

func (*MyNodeChannelClient) IsOpen 

func (c *MyNodeChannelClient) IsOpen() bool

func (*MyNodeChannelClient) Open 

func (c *MyNodeChannelClient) Open() error

type MyNodeClient 

type MyNodeClient struct {
	MyNodeClientInterface
	*MyRootClient
}

func NewMyNodeClient 

func NewMyNodeClient(t thrift.Transport, iprot thrift.Protocol, oprot thrift.Protocol) *MyNodeClient

func NewMyNodeClientFactory 

func NewMyNodeClientFactory(t thrift.Transport, f thrift.ProtocolFactory) *MyNodeClient

func NewMyNodeClientProtocol 

func NewMyNodeClientProtocol(prot thrift.Protocol) *MyNodeClient

func (*MyNodeClient) Close 

func (client *MyNodeClient) Close() error

func (*MyNodeClient) DoMid 

func (p *MyNodeClient) DoMid() (err error)

func (*MyNodeClient) IsOpen 

func (client *MyNodeClient) IsOpen() bool

func (*MyNodeClient) Open 

func (client *MyNodeClient) Open() error

type MyNodeClientInterface 

type MyNodeClientInterface interface {
	thrift.ClientInterface
	DoMid() (err error)
}

type MyNodeDoMidArgs 

type MyNodeDoMidArgs struct {
	thrift.IRequest
}

func NewMyNodeDoMidArgs 

func NewMyNodeDoMidArgs() *MyNodeDoMidArgs

func (*MyNodeDoMidArgs) Read 

func (p *MyNodeDoMidArgs) Read(iprot thrift.Protocol) error

func (*MyNodeDoMidArgs) String 

func (p *MyNodeDoMidArgs) String() string

func (*MyNodeDoMidArgs) Write 

func (p *MyNodeDoMidArgs) Write(oprot thrift.Protocol) error

type MyNodeDoMidArgsBuilder 

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

func NewMyNodeDoMidArgsBuilder 

func NewMyNodeDoMidArgsBuilder() *MyNodeDoMidArgsBuilder

func (MyNodeDoMidArgsBuilder) Emit 

func (p MyNodeDoMidArgsBuilder) Emit() *MyNodeDoMidArgs

type MyNodeDoMidResult 

type MyNodeDoMidResult struct {
	thrift.IResponse
}

func NewMyNodeDoMidResult 

func NewMyNodeDoMidResult() *MyNodeDoMidResult

func (*MyNodeDoMidResult) Exception 

func (p *MyNodeDoMidResult) Exception() thrift.WritableException

func (*MyNodeDoMidResult) Read 

func (p *MyNodeDoMidResult) Read(iprot thrift.Protocol) error

func (*MyNodeDoMidResult) String 

func (p *MyNodeDoMidResult) String() string

func (*MyNodeDoMidResult) Write 

func (p *MyNodeDoMidResult) Write(oprot thrift.Protocol) error

type MyNodeDoMidResultBuilder 

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

func NewMyNodeDoMidResultBuilder 

func NewMyNodeDoMidResultBuilder() *MyNodeDoMidResultBuilder

func (MyNodeDoMidResultBuilder) Emit 

func (p MyNodeDoMidResultBuilder) Emit() *MyNodeDoMidResult

type MyNodeProcessor 

type MyNodeProcessor struct {
	*MyRootProcessor
}

func NewMyNodeProcessor 

func NewMyNodeProcessor(handler MyNode) *MyNodeProcessor

type MyNodeThreadsafeClient 

type MyNodeThreadsafeClient struct {
	MyNodeClientInterface
	*MyRootThreadsafeClient
}

func NewMyNodeThreadsafeClient 

func NewMyNodeThreadsafeClient(t thrift.Transport, iprot thrift.Protocol, oprot thrift.Protocol) *MyNodeThreadsafeClient

func NewMyNodeThreadsafeClientFactory 

func NewMyNodeThreadsafeClientFactory(t thrift.Transport, f thrift.ProtocolFactory) *MyNodeThreadsafeClient

func NewMyNodeThreadsafeClientProtocol 

func NewMyNodeThreadsafeClientProtocol(prot thrift.Protocol) *MyNodeThreadsafeClient

func (*MyNodeThreadsafeClient) Close 

func (client *MyNodeThreadsafeClient) Close() error

func (*MyNodeThreadsafeClient) DoMid 

func (p *MyNodeThreadsafeClient) DoMid() (err error)

func (*MyNodeThreadsafeClient) IsOpen 

func (client *MyNodeThreadsafeClient) IsOpen() bool

func (*MyNodeThreadsafeClient) Open 

func (client *MyNodeThreadsafeClient) Open() error

type MyRoot 

type MyRoot interface {
	DoRoot() (err error)
}

type MyRootChannelClient 

type MyRootChannelClient struct {
	RequestChannel thrift.RequestChannel
}

func NewMyRootChannelClient 

func NewMyRootChannelClient(channel thrift.RequestChannel) *MyRootChannelClient

func (*MyRootChannelClient) Close 

func (c *MyRootChannelClient) Close() error

func (*MyRootChannelClient) DoRoot 

func (p *MyRootChannelClient) DoRoot(ctx context.Context) (err error)

func (*MyRootChannelClient) IsOpen 

func (c *MyRootChannelClient) IsOpen() bool

func (*MyRootChannelClient) Open 

func (c *MyRootChannelClient) Open() error

type MyRootClient 

type MyRootClient struct {
	MyRootClientInterface
	CC thrift.ClientConn
}

func NewMyRootClient 

func NewMyRootClient(t thrift.Transport, iprot thrift.Protocol, oprot thrift.Protocol) *MyRootClient

func NewMyRootClientFactory 

func NewMyRootClientFactory(t thrift.Transport, f thrift.ProtocolFactory) *MyRootClient

func NewMyRootClientProtocol 

func NewMyRootClientProtocol(prot thrift.Protocol) *MyRootClient

func (*MyRootClient) Close 

func (client *MyRootClient) Close() error

func (*MyRootClient) DoRoot 

func (p *MyRootClient) DoRoot() (err error)

func (*MyRootClient) IsOpen 

func (client *MyRootClient) IsOpen() bool

func (*MyRootClient) Open 

func (client *MyRootClient) Open() error

type MyRootClientInterface 

type MyRootClientInterface interface {
	thrift.ClientInterface
	DoRoot() (err error)
}

type MyRootDoRootArgs 

type MyRootDoRootArgs struct {
	thrift.IRequest
}

func NewMyRootDoRootArgs 

func NewMyRootDoRootArgs() *MyRootDoRootArgs

func (*MyRootDoRootArgs) Read 

func (p *MyRootDoRootArgs) Read(iprot thrift.Protocol) error

func (*MyRootDoRootArgs) String 

func (p *MyRootDoRootArgs) String() string

func (*MyRootDoRootArgs) Write 

func (p *MyRootDoRootArgs) Write(oprot thrift.Protocol) error

type MyRootDoRootArgsBuilder 

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

func NewMyRootDoRootArgsBuilder 

func NewMyRootDoRootArgsBuilder() *MyRootDoRootArgsBuilder

func (MyRootDoRootArgsBuilder) Emit 

func (p MyRootDoRootArgsBuilder) Emit() *MyRootDoRootArgs

type MyRootDoRootResult 

type MyRootDoRootResult struct {
	thrift.IResponse
}

func NewMyRootDoRootResult 

func NewMyRootDoRootResult() *MyRootDoRootResult

func (*MyRootDoRootResult) Exception 

func (p *MyRootDoRootResult) Exception() thrift.WritableException

func (*MyRootDoRootResult) Read 

func (p *MyRootDoRootResult) Read(iprot thrift.Protocol) error

func (*MyRootDoRootResult) String 

func (p *MyRootDoRootResult) String() string

func (*MyRootDoRootResult) Write 

func (p *MyRootDoRootResult) Write(oprot thrift.Protocol) error

type MyRootDoRootResultBuilder 

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

func NewMyRootDoRootResultBuilder 

func NewMyRootDoRootResultBuilder() *MyRootDoRootResultBuilder

func (MyRootDoRootResultBuilder) Emit 

func (p MyRootDoRootResultBuilder) Emit() *MyRootDoRootResult

type MyRootProcessor 

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

func NewMyRootProcessor 

func NewMyRootProcessor(handler MyRoot) *MyRootProcessor

func (*MyRootProcessor) AddToFunctionServiceMap 

func (p *MyRootProcessor) AddToFunctionServiceMap(key, service string)

func (*MyRootProcessor) AddToProcessorMap 

func (p *MyRootProcessor) AddToProcessorMap(key string, processor thrift.ProcessorFunction)

func (*MyRootProcessor) FunctionServiceMap 

func (p *MyRootProcessor) FunctionServiceMap() map[string]string

func (*MyRootProcessor) GetProcessorFunction 

func (p *MyRootProcessor) GetProcessorFunction(key string) (processor thrift.ProcessorFunction, err error)

func (*MyRootProcessor) ProcessorMap 

func (p *MyRootProcessor) ProcessorMap() map[string]thrift.ProcessorFunction

type MyRootThreadsafeClient 

type MyRootThreadsafeClient struct {
	MyRootClientInterface
	CC thrift.ClientConn
	Mu sync.Mutex
}

func NewMyRootThreadsafeClient 

func NewMyRootThreadsafeClient(t thrift.Transport, iprot thrift.Protocol, oprot thrift.Protocol) *MyRootThreadsafeClient

func NewMyRootThreadsafeClientFactory 

func NewMyRootThreadsafeClientFactory(t thrift.Transport, f thrift.ProtocolFactory) *MyRootThreadsafeClient

func NewMyRootThreadsafeClientProtocol 

func NewMyRootThreadsafeClientProtocol(prot thrift.Protocol) *MyRootThreadsafeClient

func (*MyRootThreadsafeClient) Close 

func (client *MyRootThreadsafeClient) Close() error

func (*MyRootThreadsafeClient) DoRoot 

func (p *MyRootThreadsafeClient) DoRoot() (err error)

func (*MyRootThreadsafeClient) IsOpen 

func (client *MyRootThreadsafeClient) IsOpen() bool

func (*MyRootThreadsafeClient) Open 

func (client *MyRootThreadsafeClient) Open() error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.