rpc

package
v0.0.0-...-bac99df Latest Latest
Warning

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

 Go to latest Published: Apr 18, 2020 License: MIT Imports: 12 Imported by: 0

Documentation

Overview

/go:generate protoc -I=. -I=$GOPATH/src msg --gogofaster_out=plugins=grpc:. rpc.proto /go:generate protoc -I=. -I=$GOPATH/src --rpc-go_out=. --rpc-go_opt=tpl:test.tpl rpc.proto

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrInvalidLengthRpc = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRpc   = fmt.Errorf("proto: integer overflow")
)
View Source 
var E_Enable0_Slice = []int32{
	0,
	1,
}
View Source 
var E_Enable0_name = map[int32]string{
	0: "E_Enable0_",
	1: "E_Enable0_1",
}
View Source 
var E_Enable0_value = map[string]int32{
	"E_Enable0_":  0,
	"E_Enable0_1": 1,
}
View Source 
var E_Test_Slice = []int32{
	0,
	1,
	2,
}
View Source 
var E_Test_name = map[int32]string{
	0: "E_Test_",
	1: "E_Test_1",
	2: "E_Test_2",
}
View Source 
var E_Test_value = map[string]int32{
	"E_Test_":  0,
	"E_Test_1": 1,
	"E_Test_2": 2,
}
View Source 
var EnumTestMsg_E_Enable0_Slice = []int32{
	0,
	1,
}
View Source 
var EnumTestMsg_E_Enable0_name = map[int32]string{
	0: "E_Enable0_",
	1: "E_Enable0_OK",
}
View Source 
var EnumTestMsg_E_Enable0_value = map[string]int32{
	"E_Enable0_":   0,
	"E_Enable0_OK": 1,
}
View Source 
var EnumTestMsg_E_Test_Slice = []int32{
	0,
	1,
}
View Source 
var EnumTestMsg_E_Test_name = map[int32]string{
	0: "_",
	1: "_1",
}
View Source 
var EnumTestMsg_E_Test_value = map[string]int32{
	"_":  0,
	"_1": 1,
}
View Source 
var Protocol = rpc.New(nil)

Functions

func C2S_BroadcastMsgToClient_MessageID 

func C2S_BroadcastMsgToClient_MessageID() rpc.MessageID

func C2S_BroadcastMsgToClient_MessageName 

func C2S_BroadcastMsgToClient_MessageName() string

func C2S_BroadcastMsgToClient_ResponseMessageID 

func C2S_BroadcastMsgToClient_ResponseMessageID() rpc.MessageID

func C2S_Ping_MessageID 

func C2S_Ping_MessageID() rpc.MessageID

func C2S_Ping_MessageName 

func C2S_Ping_MessageName() string

func C2S_Ping_ResponseMessageID 

func C2S_Ping_ResponseMessageID() rpc.MessageID

func C2S_RecvMsgFromClient_MessageID 

func C2S_RecvMsgFromClient_MessageID() rpc.MessageID

func C2S_RecvMsgFromClient_MessageName 

func C2S_RecvMsgFromClient_MessageName() string

func C2S_RecvMsgFromClient_ResponseMessageID 

func C2S_RecvMsgFromClient_ResponseMessageID() rpc.MessageID

func C2S_Response_MessageID 

func C2S_Response_MessageID() rpc.MessageID

func C2S_Response_MessageName 

func C2S_Response_MessageName() string

func C2S_Response_ResponseMessageID 

func C2S_Response_ResponseMessageID() rpc.MessageID

func C2S_SendMsgToClient_MessageID 

func C2S_SendMsgToClient_MessageID() rpc.MessageID

func C2S_SendMsgToClient_MessageName 

func C2S_SendMsgToClient_MessageName() string

func C2S_SendMsgToClient_ResponseMessageID 

func C2S_SendMsgToClient_ResponseMessageID() rpc.MessageID

func Check_E_Enable0 

func Check_E_Enable0(value E_Enable0) bool

func Check_E_Enable0_I 

func Check_E_Enable0_I(value int32) bool

func Check_E_Test 

func Check_E_Test(value E_Test) bool

func Check_E_Test_I 

func Check_E_Test_I(value int32) bool

func Check_EnumTestMsg_E_Enable0 

func Check_EnumTestMsg_E_Enable0(value EnumTestMsg_E_Enable0) bool

func Check_EnumTestMsg_E_Enable0_I 

func Check_EnumTestMsg_E_Enable0_I(value int32) bool

func Check_EnumTestMsg_E_Test 

func Check_EnumTestMsg_E_Test(value EnumTestMsg_E_Test) bool

func Check_EnumTestMsg_E_Test_I 

func Check_EnumTestMsg_E_Test_I(value int32) bool

func E_Enable0_Len 

func E_Enable0_Len() int

func E_Test_Len 

func E_Test_Len() int

func Each_E_Enable0 

func Each_E_Enable0(f func(E_Enable0) bool)

func Each_E_Enable0_I 

func Each_E_Enable0_I(f func(int32) bool)

func Each_E_Test 

func Each_E_Test(f func(E_Test) bool)

func Each_E_Test_I 

func Each_E_Test_I(f func(int32) bool)

func Each_EnumTestMsg_E_Enable0 

func Each_EnumTestMsg_E_Enable0(f func(EnumTestMsg_E_Enable0) bool)

func Each_EnumTestMsg_E_Enable0_I 

func Each_EnumTestMsg_E_Enable0_I(f func(int32) bool)

func Each_EnumTestMsg_E_Test 

func Each_EnumTestMsg_E_Test(f func(EnumTestMsg_E_Test) bool)

func Each_EnumTestMsg_E_Test_I 

func Each_EnumTestMsg_E_Test_I(f func(int32) bool)

func EnumTestMsg_E_Enable0_Len 

func EnumTestMsg_E_Enable0_Len() int

func EnumTestMsg_E_Test_Len 

func EnumTestMsg_E_Test_Len() int

func Put_C2S_BroadcastMsgToClient 

func Put_C2S_BroadcastMsgToClient(i interface{})

func Put_C2S_Ping 

func Put_C2S_Ping(i interface{})

func Put_C2S_RecvMsgFromClient 

func Put_C2S_RecvMsgFromClient(i interface{})

func Put_C2S_Response 

func Put_C2S_Response(i interface{})

func Put_C2S_SendMsgToClient 

func Put_C2S_SendMsgToClient(i interface{})

func Put_EnumTestMsg 

func Put_EnumTestMsg(i interface{})

func Put_S2C_Pong 

func Put_S2C_Pong(i interface{})

func Put_S2C_Response 

func Put_S2C_Response(i interface{})

func Put_Test 

func Put_Test(i interface{})

func S2C_Pong_MessageID 

func S2C_Pong_MessageID() rpc.MessageID

func S2C_Pong_MessageName 

func S2C_Pong_MessageName() string

func S2C_Pong_ResponseMessageID 

func S2C_Pong_ResponseMessageID() rpc.MessageID

func S2C_Response_MessageID 

func S2C_Response_MessageID() rpc.MessageID

func S2C_Response_MessageName 

func S2C_Response_MessageName() string

func S2C_Response_ResponseMessageID 

func S2C_Response_ResponseMessageID() rpc.MessageID

Types

type C2S_BroadcastMsgToClient 

type C2S_BroadcastMsgToClient struct {
	Include []int64 `protobuf:"varint,1,rep,packed,name=Include,proto3" json:"Include,omitempty"`
	Exclude []int64 `protobuf:"varint,2,rep,packed,name=Exclude,proto3" json:"Exclude,omitempty"`
	Data    []byte  `protobuf:"bytes,3,opt,name=Data,proto3" json:"Data,omitempty"`
	T       *Test   `protobuf:"bytes,4,opt,name=T,proto3" json:"T,omitempty"`
	Ts      []*Test `protobuf:"bytes,5,rep,name=Ts,proto3" json:"Ts,omitempty"`
}

广播数据包给客户端 @msg=9

func Clone_C2S_BroadcastMsgToClient_Slice 

func Clone_C2S_BroadcastMsgToClient_Slice(dst []*C2S_BroadcastMsgToClient, src []*C2S_BroadcastMsgToClient) []*C2S_BroadcastMsgToClient

func Get_C2S_BroadcastMsgToClient 

func Get_C2S_BroadcastMsgToClient() *C2S_BroadcastMsgToClient

func New_C2S_BroadcastMsgToClient 

func New_C2S_BroadcastMsgToClient() *C2S_BroadcastMsgToClient

func (C2S_BroadcastMsgToClient) CanIgnore 

func (C2S_BroadcastMsgToClient) CanIgnore() bool

func (C2S_BroadcastMsgToClient) Clone 

func (m C2S_BroadcastMsgToClient) Clone() *C2S_BroadcastMsgToClient

func (*C2S_BroadcastMsgToClient) Descriptor 

func (*C2S_BroadcastMsgToClient) Descriptor() ([]byte, []int)

func (*C2S_BroadcastMsgToClient) GetData 

func (m *C2S_BroadcastMsgToClient) GetData() []byte

func (*C2S_BroadcastMsgToClient) GetExclude 

func (m *C2S_BroadcastMsgToClient) GetExclude() []int64

func (*C2S_BroadcastMsgToClient) GetInclude 

func (m *C2S_BroadcastMsgToClient) GetInclude() []int64

func (*C2S_BroadcastMsgToClient) GetT 

func (m *C2S_BroadcastMsgToClient) GetT() *Test

func (*C2S_BroadcastMsgToClient) GetTs 

func (m *C2S_BroadcastMsgToClient) GetTs() []*Test

func (C2S_BroadcastMsgToClient) JsonString 

func (m C2S_BroadcastMsgToClient) JsonString() string

func (*C2S_BroadcastMsgToClient) Marshal 

func (m *C2S_BroadcastMsgToClient) Marshal() (dAtA []byte, err error)

func (*C2S_BroadcastMsgToClient) MarshalTo 

func (m *C2S_BroadcastMsgToClient) MarshalTo(dAtA []byte) (int, error)

func (C2S_BroadcastMsgToClient) MessageID 

func (C2S_BroadcastMsgToClient) MessageID() rpc.MessageID

func (C2S_BroadcastMsgToClient) MessageName 

func (C2S_BroadcastMsgToClient) MessageName() string

func (*C2S_BroadcastMsgToClient) ProtoMessage 

func (*C2S_BroadcastMsgToClient) ProtoMessage()

func (C2S_BroadcastMsgToClient) RPC 

func (C2S_BroadcastMsgToClient) RPC()

func (*C2S_BroadcastMsgToClient) Reset 

func (m *C2S_BroadcastMsgToClient) Reset()

func (*C2S_BroadcastMsgToClient) ResetEx 

func (m *C2S_BroadcastMsgToClient) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_BroadcastMsgToClient begin

func (C2S_BroadcastMsgToClient) ResponseMessageID 

func (C2S_BroadcastMsgToClient) ResponseMessageID() rpc.MessageID

func (*C2S_BroadcastMsgToClient) Size 

func (m *C2S_BroadcastMsgToClient) Size() (n int)

func (*C2S_BroadcastMsgToClient) String 

func (m *C2S_BroadcastMsgToClient) String() string

func (*C2S_BroadcastMsgToClient) Unmarshal 

func (m *C2S_BroadcastMsgToClient) Unmarshal(dAtA []byte) error

func (*C2S_BroadcastMsgToClient) XXX_DiscardUnknown 

func (m *C2S_BroadcastMsgToClient) XXX_DiscardUnknown()

func (*C2S_BroadcastMsgToClient) XXX_Marshal 

func (m *C2S_BroadcastMsgToClient) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_BroadcastMsgToClient) XXX_Merge 

func (m *C2S_BroadcastMsgToClient) XXX_Merge(src proto.Message)

func (*C2S_BroadcastMsgToClient) XXX_Size 

func (m *C2S_BroadcastMsgToClient) XXX_Size() int

func (*C2S_BroadcastMsgToClient) XXX_Unmarshal 

func (m *C2S_BroadcastMsgToClient) XXX_Unmarshal(b []byte) error

type C2S_Ping 

type C2S_Ping struct {
	PID *actor.PID `protobuf:"bytes,1,opt,name=PID,proto3" json:"PID,omitempty"`
}

@msg=1 @response=S2C_Pong @request_timeout=5

func Clone_C2S_Ping_Slice 

func Clone_C2S_Ping_Slice(dst []*C2S_Ping, src []*C2S_Ping) []*C2S_Ping

func Get_C2S_Ping 

func Get_C2S_Ping() *C2S_Ping

func New_C2S_Ping 

func New_C2S_Ping() *C2S_Ping

func (C2S_Ping) CanIgnore 

func (C2S_Ping) CanIgnore() bool

func (C2S_Ping) Clone 

func (m C2S_Ping) Clone() *C2S_Ping

func (*C2S_Ping) Descriptor 

func (*C2S_Ping) Descriptor() ([]byte, []int)

func (*C2S_Ping) GetPID 

func (m *C2S_Ping) GetPID() *actor.PID

func (C2S_Ping) JsonString 

func (m C2S_Ping) JsonString() string

func (*C2S_Ping) Marshal 

func (m *C2S_Ping) Marshal() (dAtA []byte, err error)

func (*C2S_Ping) MarshalTo 

func (m *C2S_Ping) MarshalTo(dAtA []byte) (int, error)

func (C2S_Ping) MessageID 

func (C2S_Ping) MessageID() rpc.MessageID

func (C2S_Ping) MessageName 

func (C2S_Ping) MessageName() string

func (*C2S_Ping) ProtoMessage 

func (*C2S_Ping) ProtoMessage()

func (C2S_Ping) RPC 

func (C2S_Ping) RPC()

func (*C2S_Ping) Reset 

func (m *C2S_Ping) Reset()

func (*C2S_Ping) ResetEx 

func (m *C2S_Ping) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_Ping begin

func (C2S_Ping) ResponseMessageID 

func (C2S_Ping) ResponseMessageID() rpc.MessageID

func (*C2S_Ping) Size 

func (m *C2S_Ping) Size() (n int)

func (*C2S_Ping) String 

func (m *C2S_Ping) String() string

func (*C2S_Ping) Unmarshal 

func (m *C2S_Ping) Unmarshal(dAtA []byte) error

func (*C2S_Ping) XXX_DiscardUnknown 

func (m *C2S_Ping) XXX_DiscardUnknown()

func (*C2S_Ping) XXX_Marshal 

func (m *C2S_Ping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_Ping) XXX_Merge 

func (m *C2S_Ping) XXX_Merge(src proto.Message)

func (*C2S_Ping) XXX_Size 

func (m *C2S_Ping) XXX_Size() int

func (*C2S_Ping) XXX_Unmarshal 

func (m *C2S_Ping) XXX_Unmarshal(b []byte) error

type C2S_RecvMsgFromClient 

type C2S_RecvMsgFromClient struct {
	Data []byte `protobuf:"bytes,1,opt,name=Data,proto3" json:"Data,omitempty"`
}

收到客户段的数据包 @msg=7

func Clone_C2S_RecvMsgFromClient_Slice 

func Clone_C2S_RecvMsgFromClient_Slice(dst []*C2S_RecvMsgFromClient, src []*C2S_RecvMsgFromClient) []*C2S_RecvMsgFromClient

func Get_C2S_RecvMsgFromClient 

func Get_C2S_RecvMsgFromClient() *C2S_RecvMsgFromClient

func New_C2S_RecvMsgFromClient 

func New_C2S_RecvMsgFromClient() *C2S_RecvMsgFromClient

func (C2S_RecvMsgFromClient) CanIgnore 

func (C2S_RecvMsgFromClient) CanIgnore() bool

func (C2S_RecvMsgFromClient) Clone 

func (m C2S_RecvMsgFromClient) Clone() *C2S_RecvMsgFromClient

func (*C2S_RecvMsgFromClient) Descriptor 

func (*C2S_RecvMsgFromClient) Descriptor() ([]byte, []int)

func (*C2S_RecvMsgFromClient) GetData 

func (m *C2S_RecvMsgFromClient) GetData() []byte

func (C2S_RecvMsgFromClient) JsonString 

func (m C2S_RecvMsgFromClient) JsonString() string

func (*C2S_RecvMsgFromClient) Marshal 

func (m *C2S_RecvMsgFromClient) Marshal() (dAtA []byte, err error)

func (*C2S_RecvMsgFromClient) MarshalTo 

func (m *C2S_RecvMsgFromClient) MarshalTo(dAtA []byte) (int, error)

func (C2S_RecvMsgFromClient) MessageID 

func (C2S_RecvMsgFromClient) MessageID() rpc.MessageID

func (C2S_RecvMsgFromClient) MessageName 

func (C2S_RecvMsgFromClient) MessageName() string

func (*C2S_RecvMsgFromClient) ProtoMessage 

func (*C2S_RecvMsgFromClient) ProtoMessage()

func (C2S_RecvMsgFromClient) RPC 

func (C2S_RecvMsgFromClient) RPC()

func (*C2S_RecvMsgFromClient) Reset 

func (m *C2S_RecvMsgFromClient) Reset()

func (*C2S_RecvMsgFromClient) ResetEx 

func (m *C2S_RecvMsgFromClient) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_RecvMsgFromClient begin

func (C2S_RecvMsgFromClient) ResponseMessageID 

func (C2S_RecvMsgFromClient) ResponseMessageID() rpc.MessageID

func (*C2S_RecvMsgFromClient) Size 

func (m *C2S_RecvMsgFromClient) Size() (n int)

func (*C2S_RecvMsgFromClient) String 

func (m *C2S_RecvMsgFromClient) String() string

func (*C2S_RecvMsgFromClient) Unmarshal 

func (m *C2S_RecvMsgFromClient) Unmarshal(dAtA []byte) error

func (*C2S_RecvMsgFromClient) XXX_DiscardUnknown 

func (m *C2S_RecvMsgFromClient) XXX_DiscardUnknown()

func (*C2S_RecvMsgFromClient) XXX_Marshal 

func (m *C2S_RecvMsgFromClient) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_RecvMsgFromClient) XXX_Merge 

func (m *C2S_RecvMsgFromClient) XXX_Merge(src proto.Message)

func (*C2S_RecvMsgFromClient) XXX_Size 

func (m *C2S_RecvMsgFromClient) XXX_Size() int

func (*C2S_RecvMsgFromClient) XXX_Unmarshal 

func (m *C2S_RecvMsgFromClient) XXX_Unmarshal(b []byte) error

type C2S_Response 

type C2S_Response struct {
}

测试Response用 @msg=11

func Clone_C2S_Response_Slice 

func Clone_C2S_Response_Slice(dst []*C2S_Response, src []*C2S_Response) []*C2S_Response

func Get_C2S_Response 

func Get_C2S_Response() *C2S_Response

func New_C2S_Response 

func New_C2S_Response() *C2S_Response

func (C2S_Response) CanIgnore 

func (C2S_Response) CanIgnore() bool

func (C2S_Response) Clone 

func (m C2S_Response) Clone() *C2S_Response

func (*C2S_Response) Descriptor 

func (*C2S_Response) Descriptor() ([]byte, []int)

func (C2S_Response) JsonString 

func (m C2S_Response) JsonString() string

func (*C2S_Response) Marshal 

func (m *C2S_Response) Marshal() (dAtA []byte, err error)

func (*C2S_Response) MarshalTo 

func (m *C2S_Response) MarshalTo(dAtA []byte) (int, error)

func (C2S_Response) MessageID 

func (C2S_Response) MessageID() rpc.MessageID

func (C2S_Response) MessageName 

func (C2S_Response) MessageName() string

func (*C2S_Response) ProtoMessage 

func (*C2S_Response) ProtoMessage()

func (C2S_Response) RPC 

func (C2S_Response) RPC()

func (*C2S_Response) Reset 

func (m *C2S_Response) Reset()

func (*C2S_Response) ResetEx 

func (m *C2S_Response) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_Response begin

func (C2S_Response) ResponseMessageID 

func (C2S_Response) ResponseMessageID() rpc.MessageID

func (*C2S_Response) Size 

func (m *C2S_Response) Size() (n int)

func (*C2S_Response) String 

func (m *C2S_Response) String() string

func (*C2S_Response) Unmarshal 

func (m *C2S_Response) Unmarshal(dAtA []byte) error

func (*C2S_Response) XXX_DiscardUnknown 

func (m *C2S_Response) XXX_DiscardUnknown()

func (*C2S_Response) XXX_Marshal 

func (m *C2S_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_Response) XXX_Merge 

func (m *C2S_Response) XXX_Merge(src proto.Message)

func (*C2S_Response) XXX_Size 

func (m *C2S_Response) XXX_Size() int

func (*C2S_Response) XXX_Unmarshal 

func (m *C2S_Response) XXX_Unmarshal(b []byte) error

type C2S_SendMsgToClient 

type C2S_SendMsgToClient struct {
	Data []byte `protobuf:"bytes,1,opt,name=Data,proto3" json:"Data,omitempty"`
}

发送数据包给客户端 @msg=8

func Clone_C2S_SendMsgToClient_Slice 

func Clone_C2S_SendMsgToClient_Slice(dst []*C2S_SendMsgToClient, src []*C2S_SendMsgToClient) []*C2S_SendMsgToClient

func Get_C2S_SendMsgToClient 

func Get_C2S_SendMsgToClient() *C2S_SendMsgToClient

func New_C2S_SendMsgToClient 

func New_C2S_SendMsgToClient() *C2S_SendMsgToClient

func (C2S_SendMsgToClient) CanIgnore 

func (C2S_SendMsgToClient) CanIgnore() bool

func (C2S_SendMsgToClient) Clone 

func (m C2S_SendMsgToClient) Clone() *C2S_SendMsgToClient

func (*C2S_SendMsgToClient) Descriptor 

func (*C2S_SendMsgToClient) Descriptor() ([]byte, []int)

func (*C2S_SendMsgToClient) GetData 

func (m *C2S_SendMsgToClient) GetData() []byte

func (C2S_SendMsgToClient) JsonString 

func (m C2S_SendMsgToClient) JsonString() string

func (*C2S_SendMsgToClient) Marshal 

func (m *C2S_SendMsgToClient) Marshal() (dAtA []byte, err error)

func (*C2S_SendMsgToClient) MarshalTo 

func (m *C2S_SendMsgToClient) MarshalTo(dAtA []byte) (int, error)

func (C2S_SendMsgToClient) MessageID 

func (C2S_SendMsgToClient) MessageID() rpc.MessageID

func (C2S_SendMsgToClient) MessageName 

func (C2S_SendMsgToClient) MessageName() string

func (*C2S_SendMsgToClient) ProtoMessage 

func (*C2S_SendMsgToClient) ProtoMessage()

func (C2S_SendMsgToClient) RPC 

func (C2S_SendMsgToClient) RPC()

func (*C2S_SendMsgToClient) Reset 

func (m *C2S_SendMsgToClient) Reset()

func (*C2S_SendMsgToClient) ResetEx 

func (m *C2S_SendMsgToClient) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message C2S_SendMsgToClient begin

func (C2S_SendMsgToClient) ResponseMessageID 

func (C2S_SendMsgToClient) ResponseMessageID() rpc.MessageID

func (*C2S_SendMsgToClient) Size 

func (m *C2S_SendMsgToClient) Size() (n int)

func (*C2S_SendMsgToClient) String 

func (m *C2S_SendMsgToClient) String() string

func (*C2S_SendMsgToClient) Unmarshal 

func (m *C2S_SendMsgToClient) Unmarshal(dAtA []byte) error

func (*C2S_SendMsgToClient) XXX_DiscardUnknown 

func (m *C2S_SendMsgToClient) XXX_DiscardUnknown()

func (*C2S_SendMsgToClient) XXX_Marshal 

func (m *C2S_SendMsgToClient) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*C2S_SendMsgToClient) XXX_Merge 

func (m *C2S_SendMsgToClient) XXX_Merge(src proto.Message)

func (*C2S_SendMsgToClient) XXX_Size 

func (m *C2S_SendMsgToClient) XXX_Size() int

func (*C2S_SendMsgToClient) XXX_Unmarshal 

func (m *C2S_SendMsgToClient) XXX_Unmarshal(b []byte) error

type E_Enable0 

type E_Enable0 int32

测试枚举2 @enable_0=true 

const (
	E_Enable0_E_Enable0_  E_Enable0 = 0
	E_Enable0_E_Enable0_1 E_Enable0 = 1
)

func (E_Enable0) EnumDescriptor 

func (E_Enable0) EnumDescriptor() ([]byte, []int)

func (E_Enable0) String 

func (x E_Enable0) String() string

type E_Test 

type E_Test int32

测试枚举2 

const (
	E_Test_E_Test_ E_Test = 0
	//1
	E_Test_E_Test_1 E_Test = 1
	//2
	E_Test_E_Test_2 E_Test = 2
)

func (E_Test) EnumDescriptor 

func (E_Test) EnumDescriptor() ([]byte, []int)

func (E_Test) String 

func (x E_Test) String() string

type EnumTestMsg 

type EnumTestMsg struct {
}

@can_ignore

func Clone_EnumTestMsg_Slice 

func Clone_EnumTestMsg_Slice(dst []*EnumTestMsg, src []*EnumTestMsg) []*EnumTestMsg

func Get_EnumTestMsg 

func Get_EnumTestMsg() *EnumTestMsg

func New_EnumTestMsg 

func New_EnumTestMsg() *EnumTestMsg

func (EnumTestMsg) CanIgnore 

func (EnumTestMsg) CanIgnore() bool

func (EnumTestMsg) Clone 

func (m EnumTestMsg) Clone() *EnumTestMsg

func (*EnumTestMsg) Descriptor 

func (*EnumTestMsg) Descriptor() ([]byte, []int)

func (EnumTestMsg) JsonString 

func (m EnumTestMsg) JsonString() string

func (*EnumTestMsg) Marshal 

func (m *EnumTestMsg) Marshal() (dAtA []byte, err error)

func (*EnumTestMsg) MarshalTo 

func (m *EnumTestMsg) MarshalTo(dAtA []byte) (int, error)

func (*EnumTestMsg) ProtoMessage 

func (*EnumTestMsg) ProtoMessage()

func (*EnumTestMsg) Reset 

func (m *EnumTestMsg) Reset()

func (*EnumTestMsg) ResetEx 

func (m *EnumTestMsg) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message EnumTestMsg begin

func (*EnumTestMsg) Size 

func (m *EnumTestMsg) Size() (n int)

func (*EnumTestMsg) String 

func (m *EnumTestMsg) String() string

func (*EnumTestMsg) Unmarshal 

func (m *EnumTestMsg) Unmarshal(dAtA []byte) error

func (*EnumTestMsg) XXX_DiscardUnknown 

func (m *EnumTestMsg) XXX_DiscardUnknown()

func (*EnumTestMsg) XXX_Marshal 

func (m *EnumTestMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EnumTestMsg) XXX_Merge 

func (m *EnumTestMsg) XXX_Merge(src proto.Message)

func (*EnumTestMsg) XXX_Size 

func (m *EnumTestMsg) XXX_Size() int

func (*EnumTestMsg) XXX_Unmarshal 

func (m *EnumTestMsg) XXX_Unmarshal(b []byte) error

type EnumTestMsg_E_Enable0 

type EnumTestMsg_E_Enable0 int32

/消息中的枚举2 @enable_0 

const (
	EnumTestMsg_E_Enable0_ EnumTestMsg_E_Enable0 = 0
	//OK
	EnumTestMsg_E_Enable0_OK EnumTestMsg_E_Enable0 = 1
)

func (EnumTestMsg_E_Enable0) EnumDescriptor 

func (EnumTestMsg_E_Enable0) EnumDescriptor() ([]byte, []int)

func (EnumTestMsg_E_Enable0) String 

func (x EnumTestMsg_E_Enable0) String() string

type EnumTestMsg_E_Test 

type EnumTestMsg_E_Test int32

消息中的枚举 

const (
	EnumTestMsg__ EnumTestMsg_E_Test = 0
	//1
	EnumTestMsg__1 EnumTestMsg_E_Test = 1
)

func (EnumTestMsg_E_Test) EnumDescriptor 

func (EnumTestMsg_E_Test) EnumDescriptor() ([]byte, []int)

func (EnumTestMsg_E_Test) String 

func (x EnumTestMsg_E_Test) String() string

type S2C_Pong 

type S2C_Pong struct {
	PID *actor.PID `protobuf:"bytes,1,opt,name=PID,proto3" json:"PID,omitempty"`
}

@msg=2

func Clone_S2C_Pong_Slice 

func Clone_S2C_Pong_Slice(dst []*S2C_Pong, src []*S2C_Pong) []*S2C_Pong

func Get_S2C_Pong 

func Get_S2C_Pong() *S2C_Pong

func New_S2C_Pong 

func New_S2C_Pong() *S2C_Pong

func Request_S2C_Pong 

func Request_S2C_Pong(pid *actor.PID, send *C2S_Ping) (*S2C_Pong, error)

func Request_S2C_Pong_T 

func Request_S2C_Pong_T(pid *actor.PID, send *C2S_Ping, timeout time.Duration) (*S2C_Pong, error)

func (S2C_Pong) CanIgnore 

func (S2C_Pong) CanIgnore() bool

func (S2C_Pong) Clone 

func (m S2C_Pong) Clone() *S2C_Pong

func (*S2C_Pong) Descriptor 

func (*S2C_Pong) Descriptor() ([]byte, []int)

func (*S2C_Pong) GetPID 

func (m *S2C_Pong) GetPID() *actor.PID

func (S2C_Pong) JsonString 

func (m S2C_Pong) JsonString() string

func (*S2C_Pong) Marshal 

func (m *S2C_Pong) Marshal() (dAtA []byte, err error)

func (*S2C_Pong) MarshalTo 

func (m *S2C_Pong) MarshalTo(dAtA []byte) (int, error)

func (S2C_Pong) MessageID 

func (S2C_Pong) MessageID() rpc.MessageID

func (S2C_Pong) MessageName 

func (S2C_Pong) MessageName() string

func (*S2C_Pong) ProtoMessage 

func (*S2C_Pong) ProtoMessage()

func (S2C_Pong) RPC 

func (S2C_Pong) RPC()

func (*S2C_Pong) Reset 

func (m *S2C_Pong) Reset()

func (*S2C_Pong) ResetEx 

func (m *S2C_Pong) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message S2C_Pong begin

func (S2C_Pong) ResponseMessageID 

func (S2C_Pong) ResponseMessageID() rpc.MessageID

func (*S2C_Pong) Size 

func (m *S2C_Pong) Size() (n int)

func (*S2C_Pong) String 

func (m *S2C_Pong) String() string

func (*S2C_Pong) Unmarshal 

func (m *S2C_Pong) Unmarshal(dAtA []byte) error

func (*S2C_Pong) XXX_DiscardUnknown 

func (m *S2C_Pong) XXX_DiscardUnknown()

func (*S2C_Pong) XXX_Marshal 

func (m *S2C_Pong) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*S2C_Pong) XXX_Merge 

func (m *S2C_Pong) XXX_Merge(src proto.Message)

func (*S2C_Pong) XXX_Size 

func (m *S2C_Pong) XXX_Size() int

func (*S2C_Pong) XXX_Unmarshal 

func (m *S2C_Pong) XXX_Unmarshal(b []byte) error

type S2C_Response 

type S2C_Response struct {
}

测试Response用 @msg=12

func Clone_S2C_Response_Slice 

func Clone_S2C_Response_Slice(dst []*S2C_Response, src []*S2C_Response) []*S2C_Response

func Get_S2C_Response 

func Get_S2C_Response() *S2C_Response

func New_S2C_Response 

func New_S2C_Response() *S2C_Response

func Request_S2C_Response 

func Request_S2C_Response(pid *actor.PID, send *C2S_Response) (*S2C_Response, error)

func Request_S2C_Response_T 

func Request_S2C_Response_T(pid *actor.PID, send *C2S_Response, timeout time.Duration) (*S2C_Response, error)

func (S2C_Response) CanIgnore 

func (S2C_Response) CanIgnore() bool

func (S2C_Response) Clone 

func (m S2C_Response) Clone() *S2C_Response

func (*S2C_Response) Descriptor 

func (*S2C_Response) Descriptor() ([]byte, []int)

func (S2C_Response) JsonString 

func (m S2C_Response) JsonString() string

func (*S2C_Response) Marshal 

func (m *S2C_Response) Marshal() (dAtA []byte, err error)

func (*S2C_Response) MarshalTo 

func (m *S2C_Response) MarshalTo(dAtA []byte) (int, error)

func (S2C_Response) MessageID 

func (S2C_Response) MessageID() rpc.MessageID

func (S2C_Response) MessageName 

func (S2C_Response) MessageName() string

func (*S2C_Response) ProtoMessage 

func (*S2C_Response) ProtoMessage()

func (S2C_Response) RPC 

func (S2C_Response) RPC()

func (*S2C_Response) Reset 

func (m *S2C_Response) Reset()

func (*S2C_Response) ResetEx 

func (m *S2C_Response) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message S2C_Response begin

func (S2C_Response) ResponseMessageID 

func (S2C_Response) ResponseMessageID() rpc.MessageID

func (*S2C_Response) Size 

func (m *S2C_Response) Size() (n int)

func (*S2C_Response) String 

func (m *S2C_Response) String() string

func (*S2C_Response) Unmarshal 

func (m *S2C_Response) Unmarshal(dAtA []byte) error

func (*S2C_Response) XXX_DiscardUnknown 

func (m *S2C_Response) XXX_DiscardUnknown()

func (*S2C_Response) XXX_Marshal 

func (m *S2C_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*S2C_Response) XXX_Merge 

func (m *S2C_Response) XXX_Merge(src proto.Message)

func (*S2C_Response) XXX_Size 

func (m *S2C_Response) XXX_Size() int

func (*S2C_Response) XXX_Unmarshal 

func (m *S2C_Response) XXX_Unmarshal(b []byte) error

type Test 

type Test struct {
	ID   int64  `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
	Name string `protobuf:"bytes,2,opt,name=Name,proto3" json:"Name,omitempty"`
}

func Clone_Test_Slice 

func Clone_Test_Slice(dst []*Test, src []*Test) []*Test

func Get_Test 

func Get_Test() *Test

func New_Test 

func New_Test() *Test

func (Test) CanIgnore 

func (Test) CanIgnore() bool

func (Test) Clone 

func (m Test) Clone() *Test

func (*Test) Descriptor 

func (*Test) Descriptor() ([]byte, []int)

func (*Test) GetID 

func (m *Test) GetID() int64

func (*Test) GetName 

func (m *Test) GetName() string

func (Test) JsonString 

func (m Test) JsonString() string

func (*Test) Marshal 

func (m *Test) Marshal() (dAtA []byte, err error)

func (*Test) MarshalTo 

func (m *Test) MarshalTo(dAtA []byte) (int, error)

func (*Test) ProtoMessage 

func (*Test) ProtoMessage()

func (*Test) Reset 

func (m *Test) Reset()

func (*Test) ResetEx 

func (m *Test) ResetEx()

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// message Test begin

func (*Test) Size 

func (m *Test) Size() (n int)

func (*Test) String 

func (m *Test) String() string

func (*Test) Unmarshal 

func (m *Test) Unmarshal(dAtA []byte) error

func (*Test) XXX_DiscardUnknown 

func (m *Test) XXX_DiscardUnknown()

func (*Test) XXX_Marshal 

func (m *Test) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Test) XXX_Merge 

func (m *Test) XXX_Merge(src proto.Message)

func (*Test) XXX_Size 

func (m *Test) XXX_Size() int

func (*Test) XXX_Unmarshal 

func (m *Test) XXX_Unmarshal(b []byte) 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.