You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3373 lines
86 KiB
3373 lines
86 KiB
// Code generated by protoc-gen-gogo. DO NOT EDIT. |
|
// source: app/service/live/broadcast-proxy/api/v1/api.proto |
|
|
|
package v1 |
|
|
|
import proto "github.com/gogo/protobuf/proto" |
|
import fmt "fmt" |
|
import math "math" |
|
import _ "github.com/gogo/protobuf/gogoproto" |
|
|
|
import ( |
|
context "golang.org/x/net/context" |
|
grpc "google.golang.org/grpc" |
|
) |
|
|
|
import io "io" |
|
|
|
// Reference imports to suppress errors if they are not otherwise used. |
|
var _ = proto.Marshal |
|
var _ = fmt.Errorf |
|
var _ = math.Inf |
|
|
|
// This is a compile-time assertion to ensure that this generated file |
|
// is compatible with the proto package it is being compiled against. |
|
// A compilation error at this line likely means your copy of the |
|
// proto package needs to be updated. |
|
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package |
|
|
|
type GeneralResponse struct { |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *GeneralResponse) Reset() { *m = GeneralResponse{} } |
|
func (m *GeneralResponse) String() string { return proto.CompactTextString(m) } |
|
func (*GeneralResponse) ProtoMessage() {} |
|
func (*GeneralResponse) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{0} |
|
} |
|
func (m *GeneralResponse) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *GeneralResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_GeneralResponse.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *GeneralResponse) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_GeneralResponse.Merge(dst, src) |
|
} |
|
func (m *GeneralResponse) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *GeneralResponse) XXX_DiscardUnknown() { |
|
xxx_messageInfo_GeneralResponse.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_GeneralResponse proto.InternalMessageInfo |
|
|
|
type RoomMessageRequest struct { |
|
RoomId int32 `protobuf:"varint,1,opt,name=room_id,json=roomId,proto3" json:"room_id"` |
|
Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"msg"` |
|
Ensure int32 `protobuf:"varint,3,opt,name=ensure,proto3" json:"ensure,omitempty"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *RoomMessageRequest) Reset() { *m = RoomMessageRequest{} } |
|
func (m *RoomMessageRequest) String() string { return proto.CompactTextString(m) } |
|
func (*RoomMessageRequest) ProtoMessage() {} |
|
func (*RoomMessageRequest) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{1} |
|
} |
|
func (m *RoomMessageRequest) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *RoomMessageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_RoomMessageRequest.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *RoomMessageRequest) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_RoomMessageRequest.Merge(dst, src) |
|
} |
|
func (m *RoomMessageRequest) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *RoomMessageRequest) XXX_DiscardUnknown() { |
|
xxx_messageInfo_RoomMessageRequest.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_RoomMessageRequest proto.InternalMessageInfo |
|
|
|
func (m *RoomMessageRequest) GetRoomId() int32 { |
|
if m != nil { |
|
return m.RoomId |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *RoomMessageRequest) GetMessage() string { |
|
if m != nil { |
|
return m.Message |
|
} |
|
return "" |
|
} |
|
|
|
func (m *RoomMessageRequest) GetEnsure() int32 { |
|
if m != nil { |
|
return m.Ensure |
|
} |
|
return 0 |
|
} |
|
|
|
type BroadcastMessageRequest struct { |
|
Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` |
|
ExcludeRoomId []int32 `protobuf:"varint,2,rep,packed,name=exclude_room_id,json=excludeRoomId" json:"exclude_room_id,omitempty"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *BroadcastMessageRequest) Reset() { *m = BroadcastMessageRequest{} } |
|
func (m *BroadcastMessageRequest) String() string { return proto.CompactTextString(m) } |
|
func (*BroadcastMessageRequest) ProtoMessage() {} |
|
func (*BroadcastMessageRequest) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{2} |
|
} |
|
func (m *BroadcastMessageRequest) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *BroadcastMessageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_BroadcastMessageRequest.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *BroadcastMessageRequest) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_BroadcastMessageRequest.Merge(dst, src) |
|
} |
|
func (m *BroadcastMessageRequest) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *BroadcastMessageRequest) XXX_DiscardUnknown() { |
|
xxx_messageInfo_BroadcastMessageRequest.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_BroadcastMessageRequest proto.InternalMessageInfo |
|
|
|
func (m *BroadcastMessageRequest) GetMessage() string { |
|
if m != nil { |
|
return m.Message |
|
} |
|
return "" |
|
} |
|
|
|
func (m *BroadcastMessageRequest) GetExcludeRoomId() []int32 { |
|
if m != nil { |
|
return m.ExcludeRoomId |
|
} |
|
return nil |
|
} |
|
|
|
type MultiRoomMessageRequest struct { |
|
RoomId []int32 `protobuf:"varint,1,rep,packed,name=room_id,json=roomId" json:"room_id"` |
|
Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"msg"` |
|
Ensure int32 `protobuf:"varint,3,opt,name=ensure,proto3" json:"ensure,omitempty"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *MultiRoomMessageRequest) Reset() { *m = MultiRoomMessageRequest{} } |
|
func (m *MultiRoomMessageRequest) String() string { return proto.CompactTextString(m) } |
|
func (*MultiRoomMessageRequest) ProtoMessage() {} |
|
func (*MultiRoomMessageRequest) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{3} |
|
} |
|
func (m *MultiRoomMessageRequest) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *MultiRoomMessageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_MultiRoomMessageRequest.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *MultiRoomMessageRequest) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_MultiRoomMessageRequest.Merge(dst, src) |
|
} |
|
func (m *MultiRoomMessageRequest) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *MultiRoomMessageRequest) XXX_DiscardUnknown() { |
|
xxx_messageInfo_MultiRoomMessageRequest.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_MultiRoomMessageRequest proto.InternalMessageInfo |
|
|
|
func (m *MultiRoomMessageRequest) GetRoomId() []int32 { |
|
if m != nil { |
|
return m.RoomId |
|
} |
|
return nil |
|
} |
|
|
|
func (m *MultiRoomMessageRequest) GetMessage() string { |
|
if m != nil { |
|
return m.Message |
|
} |
|
return "" |
|
} |
|
|
|
func (m *MultiRoomMessageRequest) GetEnsure() int32 { |
|
if m != nil { |
|
return m.Ensure |
|
} |
|
return 0 |
|
} |
|
|
|
type BatchRoomMessageRequest struct { |
|
RoomMessage []*RoomMessageRequest `protobuf:"bytes,1,rep,name=room_message,json=roomMessage" json:"data"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *BatchRoomMessageRequest) Reset() { *m = BatchRoomMessageRequest{} } |
|
func (m *BatchRoomMessageRequest) String() string { return proto.CompactTextString(m) } |
|
func (*BatchRoomMessageRequest) ProtoMessage() {} |
|
func (*BatchRoomMessageRequest) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{4} |
|
} |
|
func (m *BatchRoomMessageRequest) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *BatchRoomMessageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_BatchRoomMessageRequest.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *BatchRoomMessageRequest) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_BatchRoomMessageRequest.Merge(dst, src) |
|
} |
|
func (m *BatchRoomMessageRequest) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *BatchRoomMessageRequest) XXX_DiscardUnknown() { |
|
xxx_messageInfo_BatchRoomMessageRequest.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_BatchRoomMessageRequest proto.InternalMessageInfo |
|
|
|
func (m *BatchRoomMessageRequest) GetRoomMessage() []*RoomMessageRequest { |
|
if m != nil { |
|
return m.RoomMessage |
|
} |
|
return nil |
|
} |
|
|
|
type UserMessageRequest struct { |
|
UserId int64 `protobuf:"varint,1,opt,name=user_id,json=userId,proto3" json:"uid"` |
|
Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"msg"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *UserMessageRequest) Reset() { *m = UserMessageRequest{} } |
|
func (m *UserMessageRequest) String() string { return proto.CompactTextString(m) } |
|
func (*UserMessageRequest) ProtoMessage() {} |
|
func (*UserMessageRequest) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{5} |
|
} |
|
func (m *UserMessageRequest) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *UserMessageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_UserMessageRequest.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *UserMessageRequest) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_UserMessageRequest.Merge(dst, src) |
|
} |
|
func (m *UserMessageRequest) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *UserMessageRequest) XXX_DiscardUnknown() { |
|
xxx_messageInfo_UserMessageRequest.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_UserMessageRequest proto.InternalMessageInfo |
|
|
|
func (m *UserMessageRequest) GetUserId() int64 { |
|
if m != nil { |
|
return m.UserId |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *UserMessageRequest) GetMessage() string { |
|
if m != nil { |
|
return m.Message |
|
} |
|
return "" |
|
} |
|
|
|
type BatchUserMessageRequest struct { |
|
UserMessage []*UserMessageRequest `protobuf:"bytes,1,rep,name=user_message,json=userMessage" json:"data"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *BatchUserMessageRequest) Reset() { *m = BatchUserMessageRequest{} } |
|
func (m *BatchUserMessageRequest) String() string { return proto.CompactTextString(m) } |
|
func (*BatchUserMessageRequest) ProtoMessage() {} |
|
func (*BatchUserMessageRequest) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{6} |
|
} |
|
func (m *BatchUserMessageRequest) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *BatchUserMessageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_BatchUserMessageRequest.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *BatchUserMessageRequest) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_BatchUserMessageRequest.Merge(dst, src) |
|
} |
|
func (m *BatchUserMessageRequest) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *BatchUserMessageRequest) XXX_DiscardUnknown() { |
|
xxx_messageInfo_BatchUserMessageRequest.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_BatchUserMessageRequest proto.InternalMessageInfo |
|
|
|
func (m *BatchUserMessageRequest) GetUserMessage() []*UserMessageRequest { |
|
if m != nil { |
|
return m.UserMessage |
|
} |
|
return nil |
|
} |
|
|
|
type DispatchRequest struct { |
|
UserId int64 `protobuf:"varint,1,opt,name=user_id,json=userId,proto3" json:"uid"` |
|
UserIp string `protobuf:"bytes,2,opt,name=user_ip,json=userIp,proto3" json:"ip"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *DispatchRequest) Reset() { *m = DispatchRequest{} } |
|
func (m *DispatchRequest) String() string { return proto.CompactTextString(m) } |
|
func (*DispatchRequest) ProtoMessage() {} |
|
func (*DispatchRequest) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{7} |
|
} |
|
func (m *DispatchRequest) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *DispatchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_DispatchRequest.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *DispatchRequest) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_DispatchRequest.Merge(dst, src) |
|
} |
|
func (m *DispatchRequest) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *DispatchRequest) XXX_DiscardUnknown() { |
|
xxx_messageInfo_DispatchRequest.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_DispatchRequest proto.InternalMessageInfo |
|
|
|
func (m *DispatchRequest) GetUserId() int64 { |
|
if m != nil { |
|
return m.UserId |
|
} |
|
return 0 |
|
} |
|
|
|
func (m *DispatchRequest) GetUserIp() string { |
|
if m != nil { |
|
return m.UserIp |
|
} |
|
return "" |
|
} |
|
|
|
type DispatchResponse struct { |
|
Ip []string `protobuf:"bytes,1,rep,name=ip" json:"ip"` |
|
Host []string `protobuf:"bytes,2,rep,name=host" json:"host"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *DispatchResponse) Reset() { *m = DispatchResponse{} } |
|
func (m *DispatchResponse) String() string { return proto.CompactTextString(m) } |
|
func (*DispatchResponse) ProtoMessage() {} |
|
func (*DispatchResponse) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{8} |
|
} |
|
func (m *DispatchResponse) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *DispatchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_DispatchResponse.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *DispatchResponse) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_DispatchResponse.Merge(dst, src) |
|
} |
|
func (m *DispatchResponse) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *DispatchResponse) XXX_DiscardUnknown() { |
|
xxx_messageInfo_DispatchResponse.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_DispatchResponse proto.InternalMessageInfo |
|
|
|
func (m *DispatchResponse) GetIp() []string { |
|
if m != nil { |
|
return m.Ip |
|
} |
|
return nil |
|
} |
|
|
|
func (m *DispatchResponse) GetHost() []string { |
|
if m != nil { |
|
return m.Host |
|
} |
|
return nil |
|
} |
|
|
|
type SetAngryValueRequest struct { |
|
AngryValue map[uint64]uint64 `protobuf:"bytes,1,rep,name=angry_value,json=angryValue" json:"angry_value" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *SetAngryValueRequest) Reset() { *m = SetAngryValueRequest{} } |
|
func (m *SetAngryValueRequest) String() string { return proto.CompactTextString(m) } |
|
func (*SetAngryValueRequest) ProtoMessage() {} |
|
func (*SetAngryValueRequest) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{9} |
|
} |
|
func (m *SetAngryValueRequest) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *SetAngryValueRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_SetAngryValueRequest.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *SetAngryValueRequest) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_SetAngryValueRequest.Merge(dst, src) |
|
} |
|
func (m *SetAngryValueRequest) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *SetAngryValueRequest) XXX_DiscardUnknown() { |
|
xxx_messageInfo_SetAngryValueRequest.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_SetAngryValueRequest proto.InternalMessageInfo |
|
|
|
func (m *SetAngryValueRequest) GetAngryValue() map[uint64]uint64 { |
|
if m != nil { |
|
return m.AngryValue |
|
} |
|
return nil |
|
} |
|
|
|
type SetAngryValueResponse struct { |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *SetAngryValueResponse) Reset() { *m = SetAngryValueResponse{} } |
|
func (m *SetAngryValueResponse) String() string { return proto.CompactTextString(m) } |
|
func (*SetAngryValueResponse) ProtoMessage() {} |
|
func (*SetAngryValueResponse) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{10} |
|
} |
|
func (m *SetAngryValueResponse) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *SetAngryValueResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_SetAngryValueResponse.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *SetAngryValueResponse) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_SetAngryValueResponse.Merge(dst, src) |
|
} |
|
func (m *SetAngryValueResponse) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *SetAngryValueResponse) XXX_DiscardUnknown() { |
|
xxx_messageInfo_SetAngryValueResponse.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_SetAngryValueResponse proto.InternalMessageInfo |
|
|
|
type GetRoomOnlineCountRequest struct { |
|
RoomId []uint64 `protobuf:"varint,1,rep,packed,name=room_id,json=roomId" json:"room_id"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *GetRoomOnlineCountRequest) Reset() { *m = GetRoomOnlineCountRequest{} } |
|
func (m *GetRoomOnlineCountRequest) String() string { return proto.CompactTextString(m) } |
|
func (*GetRoomOnlineCountRequest) ProtoMessage() {} |
|
func (*GetRoomOnlineCountRequest) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{11} |
|
} |
|
func (m *GetRoomOnlineCountRequest) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *GetRoomOnlineCountRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_GetRoomOnlineCountRequest.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *GetRoomOnlineCountRequest) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_GetRoomOnlineCountRequest.Merge(dst, src) |
|
} |
|
func (m *GetRoomOnlineCountRequest) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *GetRoomOnlineCountRequest) XXX_DiscardUnknown() { |
|
xxx_messageInfo_GetRoomOnlineCountRequest.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_GetRoomOnlineCountRequest proto.InternalMessageInfo |
|
|
|
func (m *GetRoomOnlineCountRequest) GetRoomId() []uint64 { |
|
if m != nil { |
|
return m.RoomId |
|
} |
|
return nil |
|
} |
|
|
|
type GetRoomOnlineCountResponse struct { |
|
RoomOnlineCount map[uint64]uint64 `protobuf:"bytes,1,rep,name=room_online_count,json=roomOnlineCount" json:"room_online_count" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` |
|
XXX_NoUnkeyedLiteral struct{} `json:"-"` |
|
XXX_unrecognized []byte `json:"-"` |
|
XXX_sizecache int32 `json:"-"` |
|
} |
|
|
|
func (m *GetRoomOnlineCountResponse) Reset() { *m = GetRoomOnlineCountResponse{} } |
|
func (m *GetRoomOnlineCountResponse) String() string { return proto.CompactTextString(m) } |
|
func (*GetRoomOnlineCountResponse) ProtoMessage() {} |
|
func (*GetRoomOnlineCountResponse) Descriptor() ([]byte, []int) { |
|
return fileDescriptor_api_4c12c799dd801cdd, []int{12} |
|
} |
|
func (m *GetRoomOnlineCountResponse) XXX_Unmarshal(b []byte) error { |
|
return m.Unmarshal(b) |
|
} |
|
func (m *GetRoomOnlineCountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { |
|
if deterministic { |
|
return xxx_messageInfo_GetRoomOnlineCountResponse.Marshal(b, m, deterministic) |
|
} else { |
|
b = b[:cap(b)] |
|
n, err := m.MarshalTo(b) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return b[:n], nil |
|
} |
|
} |
|
func (dst *GetRoomOnlineCountResponse) XXX_Merge(src proto.Message) { |
|
xxx_messageInfo_GetRoomOnlineCountResponse.Merge(dst, src) |
|
} |
|
func (m *GetRoomOnlineCountResponse) XXX_Size() int { |
|
return m.Size() |
|
} |
|
func (m *GetRoomOnlineCountResponse) XXX_DiscardUnknown() { |
|
xxx_messageInfo_GetRoomOnlineCountResponse.DiscardUnknown(m) |
|
} |
|
|
|
var xxx_messageInfo_GetRoomOnlineCountResponse proto.InternalMessageInfo |
|
|
|
func (m *GetRoomOnlineCountResponse) GetRoomOnlineCount() map[uint64]uint64 { |
|
if m != nil { |
|
return m.RoomOnlineCount |
|
} |
|
return nil |
|
} |
|
|
|
func init() { |
|
proto.RegisterType((*GeneralResponse)(nil), "live.broadcastproxy.v1.GeneralResponse") |
|
proto.RegisterType((*RoomMessageRequest)(nil), "live.broadcastproxy.v1.RoomMessageRequest") |
|
proto.RegisterType((*BroadcastMessageRequest)(nil), "live.broadcastproxy.v1.BroadcastMessageRequest") |
|
proto.RegisterType((*MultiRoomMessageRequest)(nil), "live.broadcastproxy.v1.MultiRoomMessageRequest") |
|
proto.RegisterType((*BatchRoomMessageRequest)(nil), "live.broadcastproxy.v1.BatchRoomMessageRequest") |
|
proto.RegisterType((*UserMessageRequest)(nil), "live.broadcastproxy.v1.UserMessageRequest") |
|
proto.RegisterType((*BatchUserMessageRequest)(nil), "live.broadcastproxy.v1.BatchUserMessageRequest") |
|
proto.RegisterType((*DispatchRequest)(nil), "live.broadcastproxy.v1.DispatchRequest") |
|
proto.RegisterType((*DispatchResponse)(nil), "live.broadcastproxy.v1.DispatchResponse") |
|
proto.RegisterType((*SetAngryValueRequest)(nil), "live.broadcastproxy.v1.SetAngryValueRequest") |
|
proto.RegisterMapType((map[uint64]uint64)(nil), "live.broadcastproxy.v1.SetAngryValueRequest.AngryValueEntry") |
|
proto.RegisterType((*SetAngryValueResponse)(nil), "live.broadcastproxy.v1.SetAngryValueResponse") |
|
proto.RegisterType((*GetRoomOnlineCountRequest)(nil), "live.broadcastproxy.v1.GetRoomOnlineCountRequest") |
|
proto.RegisterType((*GetRoomOnlineCountResponse)(nil), "live.broadcastproxy.v1.GetRoomOnlineCountResponse") |
|
proto.RegisterMapType((map[uint64]uint64)(nil), "live.broadcastproxy.v1.GetRoomOnlineCountResponse.RoomOnlineCountEntry") |
|
} |
|
|
|
// Reference imports to suppress errors if they are not otherwise used. |
|
var _ context.Context |
|
var _ grpc.ClientConn |
|
|
|
// This is a compile-time assertion to ensure that this generated file |
|
// is compatible with the grpc package it is being compiled against. |
|
const _ = grpc.SupportPackageIsVersion4 |
|
|
|
// DanmakuClient is the client API for Danmaku service. |
|
// |
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. |
|
type DanmakuClient interface { |
|
RoomMessage(ctx context.Context, in *RoomMessageRequest, opts ...grpc.CallOption) (*GeneralResponse, error) |
|
BroadcastMessage(ctx context.Context, in *BroadcastMessageRequest, opts ...grpc.CallOption) (*GeneralResponse, error) |
|
MultiRoomMessage(ctx context.Context, in *MultiRoomMessageRequest, opts ...grpc.CallOption) (*GeneralResponse, error) |
|
BatchRoomMessage(ctx context.Context, in *BatchRoomMessageRequest, opts ...grpc.CallOption) (*GeneralResponse, error) |
|
UserMessage(ctx context.Context, in *UserMessageRequest, opts ...grpc.CallOption) (*GeneralResponse, error) |
|
BatchUserMessage(ctx context.Context, in *BatchUserMessageRequest, opts ...grpc.CallOption) (*GeneralResponse, error) |
|
Dispatch(ctx context.Context, in *DispatchRequest, opts ...grpc.CallOption) (*DispatchResponse, error) |
|
SetAngryValue(ctx context.Context, in *SetAngryValueRequest, opts ...grpc.CallOption) (*SetAngryValueResponse, error) |
|
GetRoomOnlineCount(ctx context.Context, in *GetRoomOnlineCountRequest, opts ...grpc.CallOption) (*GetRoomOnlineCountResponse, error) |
|
} |
|
|
|
type danmakuClient struct { |
|
cc *grpc.ClientConn |
|
} |
|
|
|
func NewDanmakuClient(cc *grpc.ClientConn) DanmakuClient { |
|
return &danmakuClient{cc} |
|
} |
|
|
|
func (c *danmakuClient) RoomMessage(ctx context.Context, in *RoomMessageRequest, opts ...grpc.CallOption) (*GeneralResponse, error) { |
|
out := new(GeneralResponse) |
|
err := c.cc.Invoke(ctx, "/live.broadcastproxy.v1.Danmaku/RoomMessage", in, out, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *danmakuClient) BroadcastMessage(ctx context.Context, in *BroadcastMessageRequest, opts ...grpc.CallOption) (*GeneralResponse, error) { |
|
out := new(GeneralResponse) |
|
err := c.cc.Invoke(ctx, "/live.broadcastproxy.v1.Danmaku/BroadcastMessage", in, out, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *danmakuClient) MultiRoomMessage(ctx context.Context, in *MultiRoomMessageRequest, opts ...grpc.CallOption) (*GeneralResponse, error) { |
|
out := new(GeneralResponse) |
|
err := c.cc.Invoke(ctx, "/live.broadcastproxy.v1.Danmaku/MultiRoomMessage", in, out, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *danmakuClient) BatchRoomMessage(ctx context.Context, in *BatchRoomMessageRequest, opts ...grpc.CallOption) (*GeneralResponse, error) { |
|
out := new(GeneralResponse) |
|
err := c.cc.Invoke(ctx, "/live.broadcastproxy.v1.Danmaku/BatchRoomMessage", in, out, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *danmakuClient) UserMessage(ctx context.Context, in *UserMessageRequest, opts ...grpc.CallOption) (*GeneralResponse, error) { |
|
out := new(GeneralResponse) |
|
err := c.cc.Invoke(ctx, "/live.broadcastproxy.v1.Danmaku/UserMessage", in, out, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *danmakuClient) BatchUserMessage(ctx context.Context, in *BatchUserMessageRequest, opts ...grpc.CallOption) (*GeneralResponse, error) { |
|
out := new(GeneralResponse) |
|
err := c.cc.Invoke(ctx, "/live.broadcastproxy.v1.Danmaku/BatchUserMessage", in, out, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *danmakuClient) Dispatch(ctx context.Context, in *DispatchRequest, opts ...grpc.CallOption) (*DispatchResponse, error) { |
|
out := new(DispatchResponse) |
|
err := c.cc.Invoke(ctx, "/live.broadcastproxy.v1.Danmaku/Dispatch", in, out, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *danmakuClient) SetAngryValue(ctx context.Context, in *SetAngryValueRequest, opts ...grpc.CallOption) (*SetAngryValueResponse, error) { |
|
out := new(SetAngryValueResponse) |
|
err := c.cc.Invoke(ctx, "/live.broadcastproxy.v1.Danmaku/SetAngryValue", in, out, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
func (c *danmakuClient) GetRoomOnlineCount(ctx context.Context, in *GetRoomOnlineCountRequest, opts ...grpc.CallOption) (*GetRoomOnlineCountResponse, error) { |
|
out := new(GetRoomOnlineCountResponse) |
|
err := c.cc.Invoke(ctx, "/live.broadcastproxy.v1.Danmaku/GetRoomOnlineCount", in, out, opts...) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return out, nil |
|
} |
|
|
|
// DanmakuServer is the server API for Danmaku service. |
|
type DanmakuServer interface { |
|
RoomMessage(context.Context, *RoomMessageRequest) (*GeneralResponse, error) |
|
BroadcastMessage(context.Context, *BroadcastMessageRequest) (*GeneralResponse, error) |
|
MultiRoomMessage(context.Context, *MultiRoomMessageRequest) (*GeneralResponse, error) |
|
BatchRoomMessage(context.Context, *BatchRoomMessageRequest) (*GeneralResponse, error) |
|
UserMessage(context.Context, *UserMessageRequest) (*GeneralResponse, error) |
|
BatchUserMessage(context.Context, *BatchUserMessageRequest) (*GeneralResponse, error) |
|
Dispatch(context.Context, *DispatchRequest) (*DispatchResponse, error) |
|
SetAngryValue(context.Context, *SetAngryValueRequest) (*SetAngryValueResponse, error) |
|
GetRoomOnlineCount(context.Context, *GetRoomOnlineCountRequest) (*GetRoomOnlineCountResponse, error) |
|
} |
|
|
|
func RegisterDanmakuServer(s *grpc.Server, srv DanmakuServer) { |
|
s.RegisterService(&_Danmaku_serviceDesc, srv) |
|
} |
|
|
|
func _Danmaku_RoomMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(RoomMessageRequest) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(DanmakuServer).RoomMessage(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/live.broadcastproxy.v1.Danmaku/RoomMessage", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(DanmakuServer).RoomMessage(ctx, req.(*RoomMessageRequest)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Danmaku_BroadcastMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(BroadcastMessageRequest) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(DanmakuServer).BroadcastMessage(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/live.broadcastproxy.v1.Danmaku/BroadcastMessage", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(DanmakuServer).BroadcastMessage(ctx, req.(*BroadcastMessageRequest)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Danmaku_MultiRoomMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(MultiRoomMessageRequest) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(DanmakuServer).MultiRoomMessage(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/live.broadcastproxy.v1.Danmaku/MultiRoomMessage", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(DanmakuServer).MultiRoomMessage(ctx, req.(*MultiRoomMessageRequest)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Danmaku_BatchRoomMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(BatchRoomMessageRequest) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(DanmakuServer).BatchRoomMessage(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/live.broadcastproxy.v1.Danmaku/BatchRoomMessage", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(DanmakuServer).BatchRoomMessage(ctx, req.(*BatchRoomMessageRequest)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Danmaku_UserMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(UserMessageRequest) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(DanmakuServer).UserMessage(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/live.broadcastproxy.v1.Danmaku/UserMessage", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(DanmakuServer).UserMessage(ctx, req.(*UserMessageRequest)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Danmaku_BatchUserMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(BatchUserMessageRequest) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(DanmakuServer).BatchUserMessage(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/live.broadcastproxy.v1.Danmaku/BatchUserMessage", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(DanmakuServer).BatchUserMessage(ctx, req.(*BatchUserMessageRequest)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Danmaku_Dispatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(DispatchRequest) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(DanmakuServer).Dispatch(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/live.broadcastproxy.v1.Danmaku/Dispatch", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(DanmakuServer).Dispatch(ctx, req.(*DispatchRequest)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Danmaku_SetAngryValue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(SetAngryValueRequest) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(DanmakuServer).SetAngryValue(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/live.broadcastproxy.v1.Danmaku/SetAngryValue", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(DanmakuServer).SetAngryValue(ctx, req.(*SetAngryValueRequest)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
func _Danmaku_GetRoomOnlineCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { |
|
in := new(GetRoomOnlineCountRequest) |
|
if err := dec(in); err != nil { |
|
return nil, err |
|
} |
|
if interceptor == nil { |
|
return srv.(DanmakuServer).GetRoomOnlineCount(ctx, in) |
|
} |
|
info := &grpc.UnaryServerInfo{ |
|
Server: srv, |
|
FullMethod: "/live.broadcastproxy.v1.Danmaku/GetRoomOnlineCount", |
|
} |
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) { |
|
return srv.(DanmakuServer).GetRoomOnlineCount(ctx, req.(*GetRoomOnlineCountRequest)) |
|
} |
|
return interceptor(ctx, in, info, handler) |
|
} |
|
|
|
var _Danmaku_serviceDesc = grpc.ServiceDesc{ |
|
ServiceName: "live.broadcastproxy.v1.Danmaku", |
|
HandlerType: (*DanmakuServer)(nil), |
|
Methods: []grpc.MethodDesc{ |
|
{ |
|
MethodName: "RoomMessage", |
|
Handler: _Danmaku_RoomMessage_Handler, |
|
}, |
|
{ |
|
MethodName: "BroadcastMessage", |
|
Handler: _Danmaku_BroadcastMessage_Handler, |
|
}, |
|
{ |
|
MethodName: "MultiRoomMessage", |
|
Handler: _Danmaku_MultiRoomMessage_Handler, |
|
}, |
|
{ |
|
MethodName: "BatchRoomMessage", |
|
Handler: _Danmaku_BatchRoomMessage_Handler, |
|
}, |
|
{ |
|
MethodName: "UserMessage", |
|
Handler: _Danmaku_UserMessage_Handler, |
|
}, |
|
{ |
|
MethodName: "BatchUserMessage", |
|
Handler: _Danmaku_BatchUserMessage_Handler, |
|
}, |
|
{ |
|
MethodName: "Dispatch", |
|
Handler: _Danmaku_Dispatch_Handler, |
|
}, |
|
{ |
|
MethodName: "SetAngryValue", |
|
Handler: _Danmaku_SetAngryValue_Handler, |
|
}, |
|
{ |
|
MethodName: "GetRoomOnlineCount", |
|
Handler: _Danmaku_GetRoomOnlineCount_Handler, |
|
}, |
|
}, |
|
Streams: []grpc.StreamDesc{}, |
|
Metadata: "app/service/live/broadcast-proxy/api/v1/api.proto", |
|
} |
|
|
|
func (m *GeneralResponse) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *GeneralResponse) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *RoomMessageRequest) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *RoomMessageRequest) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.RoomId != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.RoomId)) |
|
} |
|
if len(m.Message) > 0 { |
|
dAtA[i] = 0x12 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.Message))) |
|
i += copy(dAtA[i:], m.Message) |
|
} |
|
if m.Ensure != 0 { |
|
dAtA[i] = 0x18 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Ensure)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *BroadcastMessageRequest) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *BroadcastMessageRequest) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if len(m.Message) > 0 { |
|
dAtA[i] = 0xa |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.Message))) |
|
i += copy(dAtA[i:], m.Message) |
|
} |
|
if len(m.ExcludeRoomId) > 0 { |
|
dAtA2 := make([]byte, len(m.ExcludeRoomId)*10) |
|
var j1 int |
|
for _, num1 := range m.ExcludeRoomId { |
|
num := uint64(num1) |
|
for num >= 1<<7 { |
|
dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80) |
|
num >>= 7 |
|
j1++ |
|
} |
|
dAtA2[j1] = uint8(num) |
|
j1++ |
|
} |
|
dAtA[i] = 0x12 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(j1)) |
|
i += copy(dAtA[i:], dAtA2[:j1]) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *MultiRoomMessageRequest) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *MultiRoomMessageRequest) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if len(m.RoomId) > 0 { |
|
dAtA4 := make([]byte, len(m.RoomId)*10) |
|
var j3 int |
|
for _, num1 := range m.RoomId { |
|
num := uint64(num1) |
|
for num >= 1<<7 { |
|
dAtA4[j3] = uint8(uint64(num)&0x7f | 0x80) |
|
num >>= 7 |
|
j3++ |
|
} |
|
dAtA4[j3] = uint8(num) |
|
j3++ |
|
} |
|
dAtA[i] = 0xa |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(j3)) |
|
i += copy(dAtA[i:], dAtA4[:j3]) |
|
} |
|
if len(m.Message) > 0 { |
|
dAtA[i] = 0x12 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.Message))) |
|
i += copy(dAtA[i:], m.Message) |
|
} |
|
if m.Ensure != 0 { |
|
dAtA[i] = 0x18 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.Ensure)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *BatchRoomMessageRequest) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *BatchRoomMessageRequest) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if len(m.RoomMessage) > 0 { |
|
for _, msg := range m.RoomMessage { |
|
dAtA[i] = 0xa |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(msg.Size())) |
|
n, err := msg.MarshalTo(dAtA[i:]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i += n |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *UserMessageRequest) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *UserMessageRequest) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.UserId != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.UserId)) |
|
} |
|
if len(m.Message) > 0 { |
|
dAtA[i] = 0x12 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.Message))) |
|
i += copy(dAtA[i:], m.Message) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *BatchUserMessageRequest) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *BatchUserMessageRequest) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if len(m.UserMessage) > 0 { |
|
for _, msg := range m.UserMessage { |
|
dAtA[i] = 0xa |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(msg.Size())) |
|
n, err := msg.MarshalTo(dAtA[i:]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
i += n |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *DispatchRequest) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *DispatchRequest) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.UserId != 0 { |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(m.UserId)) |
|
} |
|
if len(m.UserIp) > 0 { |
|
dAtA[i] = 0x12 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(len(m.UserIp))) |
|
i += copy(dAtA[i:], m.UserIp) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *DispatchResponse) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *DispatchResponse) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if len(m.Ip) > 0 { |
|
for _, s := range m.Ip { |
|
dAtA[i] = 0xa |
|
i++ |
|
l = len(s) |
|
for l >= 1<<7 { |
|
dAtA[i] = uint8(uint64(l)&0x7f | 0x80) |
|
l >>= 7 |
|
i++ |
|
} |
|
dAtA[i] = uint8(l) |
|
i++ |
|
i += copy(dAtA[i:], s) |
|
} |
|
} |
|
if len(m.Host) > 0 { |
|
for _, s := range m.Host { |
|
dAtA[i] = 0x12 |
|
i++ |
|
l = len(s) |
|
for l >= 1<<7 { |
|
dAtA[i] = uint8(uint64(l)&0x7f | 0x80) |
|
l >>= 7 |
|
i++ |
|
} |
|
dAtA[i] = uint8(l) |
|
i++ |
|
i += copy(dAtA[i:], s) |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *SetAngryValueRequest) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *SetAngryValueRequest) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if len(m.AngryValue) > 0 { |
|
for k, _ := range m.AngryValue { |
|
dAtA[i] = 0xa |
|
i++ |
|
v := m.AngryValue[k] |
|
mapSize := 1 + sovApi(uint64(k)) + 1 + sovApi(uint64(v)) |
|
i = encodeVarintApi(dAtA, i, uint64(mapSize)) |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(k)) |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(v)) |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *SetAngryValueResponse) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *SetAngryValueResponse) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *GetRoomOnlineCountRequest) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *GetRoomOnlineCountRequest) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if len(m.RoomId) > 0 { |
|
dAtA6 := make([]byte, len(m.RoomId)*10) |
|
var j5 int |
|
for _, num := range m.RoomId { |
|
for num >= 1<<7 { |
|
dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80) |
|
num >>= 7 |
|
j5++ |
|
} |
|
dAtA6[j5] = uint8(num) |
|
j5++ |
|
} |
|
dAtA[i] = 0xa |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(j5)) |
|
i += copy(dAtA[i:], dAtA6[:j5]) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func (m *GetRoomOnlineCountResponse) Marshal() (dAtA []byte, err error) { |
|
size := m.Size() |
|
dAtA = make([]byte, size) |
|
n, err := m.MarshalTo(dAtA) |
|
if err != nil { |
|
return nil, err |
|
} |
|
return dAtA[:n], nil |
|
} |
|
|
|
func (m *GetRoomOnlineCountResponse) MarshalTo(dAtA []byte) (int, error) { |
|
var i int |
|
_ = i |
|
var l int |
|
_ = l |
|
if len(m.RoomOnlineCount) > 0 { |
|
for k, _ := range m.RoomOnlineCount { |
|
dAtA[i] = 0xa |
|
i++ |
|
v := m.RoomOnlineCount[k] |
|
mapSize := 1 + sovApi(uint64(k)) + 1 + sovApi(uint64(v)) |
|
i = encodeVarintApi(dAtA, i, uint64(mapSize)) |
|
dAtA[i] = 0x8 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(k)) |
|
dAtA[i] = 0x10 |
|
i++ |
|
i = encodeVarintApi(dAtA, i, uint64(v)) |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
i += copy(dAtA[i:], m.XXX_unrecognized) |
|
} |
|
return i, nil |
|
} |
|
|
|
func encodeVarintApi(dAtA []byte, offset int, v uint64) int { |
|
for v >= 1<<7 { |
|
dAtA[offset] = uint8(v&0x7f | 0x80) |
|
v >>= 7 |
|
offset++ |
|
} |
|
dAtA[offset] = uint8(v) |
|
return offset + 1 |
|
} |
|
func (m *GeneralResponse) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *RoomMessageRequest) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if m.RoomId != 0 { |
|
n += 1 + sovApi(uint64(m.RoomId)) |
|
} |
|
l = len(m.Message) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
if m.Ensure != 0 { |
|
n += 1 + sovApi(uint64(m.Ensure)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *BroadcastMessageRequest) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
l = len(m.Message) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
if len(m.ExcludeRoomId) > 0 { |
|
l = 0 |
|
for _, e := range m.ExcludeRoomId { |
|
l += sovApi(uint64(e)) |
|
} |
|
n += 1 + sovApi(uint64(l)) + l |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *MultiRoomMessageRequest) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if len(m.RoomId) > 0 { |
|
l = 0 |
|
for _, e := range m.RoomId { |
|
l += sovApi(uint64(e)) |
|
} |
|
n += 1 + sovApi(uint64(l)) + l |
|
} |
|
l = len(m.Message) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
if m.Ensure != 0 { |
|
n += 1 + sovApi(uint64(m.Ensure)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *BatchRoomMessageRequest) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if len(m.RoomMessage) > 0 { |
|
for _, e := range m.RoomMessage { |
|
l = e.Size() |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *UserMessageRequest) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if m.UserId != 0 { |
|
n += 1 + sovApi(uint64(m.UserId)) |
|
} |
|
l = len(m.Message) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *BatchUserMessageRequest) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if len(m.UserMessage) > 0 { |
|
for _, e := range m.UserMessage { |
|
l = e.Size() |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *DispatchRequest) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if m.UserId != 0 { |
|
n += 1 + sovApi(uint64(m.UserId)) |
|
} |
|
l = len(m.UserIp) |
|
if l > 0 { |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *DispatchResponse) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if len(m.Ip) > 0 { |
|
for _, s := range m.Ip { |
|
l = len(s) |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
} |
|
if len(m.Host) > 0 { |
|
for _, s := range m.Host { |
|
l = len(s) |
|
n += 1 + l + sovApi(uint64(l)) |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *SetAngryValueRequest) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if len(m.AngryValue) > 0 { |
|
for k, v := range m.AngryValue { |
|
_ = k |
|
_ = v |
|
mapEntrySize := 1 + sovApi(uint64(k)) + 1 + sovApi(uint64(v)) |
|
n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *SetAngryValueResponse) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *GetRoomOnlineCountRequest) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if len(m.RoomId) > 0 { |
|
l = 0 |
|
for _, e := range m.RoomId { |
|
l += sovApi(uint64(e)) |
|
} |
|
n += 1 + sovApi(uint64(l)) + l |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func (m *GetRoomOnlineCountResponse) Size() (n int) { |
|
if m == nil { |
|
return 0 |
|
} |
|
var l int |
|
_ = l |
|
if len(m.RoomOnlineCount) > 0 { |
|
for k, v := range m.RoomOnlineCount { |
|
_ = k |
|
_ = v |
|
mapEntrySize := 1 + sovApi(uint64(k)) + 1 + sovApi(uint64(v)) |
|
n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) |
|
} |
|
} |
|
if m.XXX_unrecognized != nil { |
|
n += len(m.XXX_unrecognized) |
|
} |
|
return n |
|
} |
|
|
|
func sovApi(x uint64) (n int) { |
|
for { |
|
n++ |
|
x >>= 7 |
|
if x == 0 { |
|
break |
|
} |
|
} |
|
return n |
|
} |
|
func sozApi(x uint64) (n int) { |
|
return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63)))) |
|
} |
|
func (m *GeneralResponse) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: GeneralResponse: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: GeneralResponse: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *RoomMessageRequest) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: RoomMessageRequest: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: RoomMessageRequest: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field RoomId", wireType) |
|
} |
|
m.RoomId = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.RoomId |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Message = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Ensure", wireType) |
|
} |
|
m.Ensure = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Ensure |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *BroadcastMessageRequest) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: BroadcastMessageRequest: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: BroadcastMessageRequest: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Message = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 2: |
|
if wireType == 0 { |
|
var v int32 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
m.ExcludeRoomId = append(m.ExcludeRoomId, v) |
|
} else if wireType == 2 { |
|
var packedLen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
packedLen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if packedLen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + packedLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
var elementCount int |
|
var count int |
|
for _, integer := range dAtA { |
|
if integer < 128 { |
|
count++ |
|
} |
|
} |
|
elementCount = count |
|
if elementCount != 0 && len(m.ExcludeRoomId) == 0 { |
|
m.ExcludeRoomId = make([]int32, 0, elementCount) |
|
} |
|
for iNdEx < postIndex { |
|
var v int32 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
m.ExcludeRoomId = append(m.ExcludeRoomId, v) |
|
} |
|
} else { |
|
return fmt.Errorf("proto: wrong wireType = %d for field ExcludeRoomId", wireType) |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *MultiRoomMessageRequest) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: MultiRoomMessageRequest: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: MultiRoomMessageRequest: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType == 0 { |
|
var v int32 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
m.RoomId = append(m.RoomId, v) |
|
} else if wireType == 2 { |
|
var packedLen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
packedLen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if packedLen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + packedLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
var elementCount int |
|
var count int |
|
for _, integer := range dAtA { |
|
if integer < 128 { |
|
count++ |
|
} |
|
} |
|
elementCount = count |
|
if elementCount != 0 && len(m.RoomId) == 0 { |
|
m.RoomId = make([]int32, 0, elementCount) |
|
} |
|
for iNdEx < postIndex { |
|
var v int32 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
m.RoomId = append(m.RoomId, v) |
|
} |
|
} else { |
|
return fmt.Errorf("proto: wrong wireType = %d for field RoomId", wireType) |
|
} |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Message = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
case 3: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Ensure", wireType) |
|
} |
|
m.Ensure = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.Ensure |= (int32(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *BatchRoomMessageRequest) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: BatchRoomMessageRequest: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: BatchRoomMessageRequest: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field RoomMessage", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.RoomMessage = append(m.RoomMessage, &RoomMessageRequest{}) |
|
if err := m.RoomMessage[len(m.RoomMessage)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *UserMessageRequest) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: UserMessageRequest: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: UserMessageRequest: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field UserId", wireType) |
|
} |
|
m.UserId = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.UserId |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Message = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *BatchUserMessageRequest) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: BatchUserMessageRequest: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: BatchUserMessageRequest: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field UserMessage", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.UserMessage = append(m.UserMessage, &UserMessageRequest{}) |
|
if err := m.UserMessage[len(m.UserMessage)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { |
|
return err |
|
} |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *DispatchRequest) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: DispatchRequest: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: DispatchRequest: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 0 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field UserId", wireType) |
|
} |
|
m.UserId = 0 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
m.UserId |= (int64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field UserIp", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.UserIp = string(dAtA[iNdEx:postIndex]) |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *DispatchResponse) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: DispatchResponse: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: DispatchResponse: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Ip", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Ip = append(m.Ip, string(dAtA[iNdEx:postIndex])) |
|
iNdEx = postIndex |
|
case 2: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType) |
|
} |
|
var stringLen uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
stringLen |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
intStringLen := int(stringLen) |
|
if intStringLen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + intStringLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.Host = append(m.Host, string(dAtA[iNdEx:postIndex])) |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *SetAngryValueRequest) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: SetAngryValueRequest: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: SetAngryValueRequest: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field AngryValue", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
if m.AngryValue == nil { |
|
m.AngryValue = make(map[uint64]uint64) |
|
} |
|
var mapkey uint64 |
|
var mapvalue uint64 |
|
for iNdEx < postIndex { |
|
entryPreIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
if fieldNum == 1 { |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
mapkey |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
} else if fieldNum == 2 { |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
mapvalue |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
} else { |
|
iNdEx = entryPreIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > postIndex { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
m.AngryValue[mapkey] = mapvalue |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *SetAngryValueResponse) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: SetAngryValueResponse: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: SetAngryValueResponse: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *GetRoomOnlineCountRequest) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: GetRoomOnlineCountRequest: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: GetRoomOnlineCountRequest: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType == 0 { |
|
var v uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
m.RoomId = append(m.RoomId, v) |
|
} else if wireType == 2 { |
|
var packedLen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
packedLen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if packedLen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + packedLen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
var elementCount int |
|
var count int |
|
for _, integer := range dAtA { |
|
if integer < 128 { |
|
count++ |
|
} |
|
} |
|
elementCount = count |
|
if elementCount != 0 && len(m.RoomId) == 0 { |
|
m.RoomId = make([]uint64, 0, elementCount) |
|
} |
|
for iNdEx < postIndex { |
|
var v uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
v |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
m.RoomId = append(m.RoomId, v) |
|
} |
|
} else { |
|
return fmt.Errorf("proto: wrong wireType = %d for field RoomId", wireType) |
|
} |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func (m *GetRoomOnlineCountResponse) Unmarshal(dAtA []byte) error { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
preIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
wireType := int(wire & 0x7) |
|
if wireType == 4 { |
|
return fmt.Errorf("proto: GetRoomOnlineCountResponse: wiretype end group for non-group") |
|
} |
|
if fieldNum <= 0 { |
|
return fmt.Errorf("proto: GetRoomOnlineCountResponse: illegal tag %d (wire type %d)", fieldNum, wire) |
|
} |
|
switch fieldNum { |
|
case 1: |
|
if wireType != 2 { |
|
return fmt.Errorf("proto: wrong wireType = %d for field RoomOnlineCount", wireType) |
|
} |
|
var msglen int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
msglen |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
if msglen < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
postIndex := iNdEx + msglen |
|
if postIndex > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
if m.RoomOnlineCount == nil { |
|
m.RoomOnlineCount = make(map[uint64]uint64) |
|
} |
|
var mapkey uint64 |
|
var mapvalue uint64 |
|
for iNdEx < postIndex { |
|
entryPreIndex := iNdEx |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
fieldNum := int32(wire >> 3) |
|
if fieldNum == 1 { |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
mapkey |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
} else if fieldNum == 2 { |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
mapvalue |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
} else { |
|
iNdEx = entryPreIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > postIndex { |
|
return io.ErrUnexpectedEOF |
|
} |
|
iNdEx += skippy |
|
} |
|
} |
|
m.RoomOnlineCount[mapkey] = mapvalue |
|
iNdEx = postIndex |
|
default: |
|
iNdEx = preIndex |
|
skippy, err := skipApi(dAtA[iNdEx:]) |
|
if err != nil { |
|
return err |
|
} |
|
if skippy < 0 { |
|
return ErrInvalidLengthApi |
|
} |
|
if (iNdEx + skippy) > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) |
|
iNdEx += skippy |
|
} |
|
} |
|
|
|
if iNdEx > l { |
|
return io.ErrUnexpectedEOF |
|
} |
|
return nil |
|
} |
|
func skipApi(dAtA []byte) (n int, err error) { |
|
l := len(dAtA) |
|
iNdEx := 0 |
|
for iNdEx < l { |
|
var wire uint64 |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return 0, ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return 0, io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
wire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
wireType := int(wire & 0x7) |
|
switch wireType { |
|
case 0: |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return 0, ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return 0, io.ErrUnexpectedEOF |
|
} |
|
iNdEx++ |
|
if dAtA[iNdEx-1] < 0x80 { |
|
break |
|
} |
|
} |
|
return iNdEx, nil |
|
case 1: |
|
iNdEx += 8 |
|
return iNdEx, nil |
|
case 2: |
|
var length int |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return 0, ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return 0, io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
length |= (int(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
iNdEx += length |
|
if length < 0 { |
|
return 0, ErrInvalidLengthApi |
|
} |
|
return iNdEx, nil |
|
case 3: |
|
for { |
|
var innerWire uint64 |
|
var start int = iNdEx |
|
for shift := uint(0); ; shift += 7 { |
|
if shift >= 64 { |
|
return 0, ErrIntOverflowApi |
|
} |
|
if iNdEx >= l { |
|
return 0, io.ErrUnexpectedEOF |
|
} |
|
b := dAtA[iNdEx] |
|
iNdEx++ |
|
innerWire |= (uint64(b) & 0x7F) << shift |
|
if b < 0x80 { |
|
break |
|
} |
|
} |
|
innerWireType := int(innerWire & 0x7) |
|
if innerWireType == 4 { |
|
break |
|
} |
|
next, err := skipApi(dAtA[start:]) |
|
if err != nil { |
|
return 0, err |
|
} |
|
iNdEx = start + next |
|
} |
|
return iNdEx, nil |
|
case 4: |
|
return iNdEx, nil |
|
case 5: |
|
iNdEx += 4 |
|
return iNdEx, nil |
|
default: |
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType) |
|
} |
|
} |
|
panic("unreachable") |
|
} |
|
|
|
var ( |
|
ErrInvalidLengthApi = fmt.Errorf("proto: negative length found during unmarshaling") |
|
ErrIntOverflowApi = fmt.Errorf("proto: integer overflow") |
|
) |
|
|
|
func init() { |
|
proto.RegisterFile("app/service/live/broadcast-proxy/api/v1/api.proto", fileDescriptor_api_4c12c799dd801cdd) |
|
} |
|
|
|
var fileDescriptor_api_4c12c799dd801cdd = []byte{ |
|
// 748 bytes of a gzipped FileDescriptorProto |
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0xdf, 0x6b, 0xd3, 0x50, |
|
0x18, 0x25, 0x69, 0xd7, 0x6e, 0x5f, 0x37, 0xda, 0x5d, 0xb6, 0xb5, 0x16, 0x59, 0x6b, 0x10, 0x2d, |
|
0xe2, 0x12, 0x3a, 0x5f, 0x44, 0xf4, 0x61, 0x71, 0x32, 0x7d, 0x18, 0x42, 0xfc, 0x31, 0x54, 0xa4, |
|
0xdc, 0xb6, 0xd7, 0x2e, 0x2c, 0xcd, 0x8d, 0x37, 0x49, 0x59, 0xf5, 0x3f, 0xf0, 0xff, 0x12, 0x7c, |
|
0x14, 0x7c, 0x2f, 0xb2, 0xc7, 0x82, 0xff, 0x83, 0xe4, 0x26, 0x69, 0xba, 0x34, 0xd9, 0x1a, 0xc4, |
|
0x97, 0x2d, 0xf7, 0xbb, 0xe7, 0x9e, 0xf3, 0x9d, 0x2f, 0xb9, 0x87, 0x42, 0x1b, 0x5b, 0x96, 0x62, |
|
0x13, 0x36, 0xd2, 0x7b, 0x44, 0x31, 0xf4, 0x11, 0x51, 0xba, 0x8c, 0xe2, 0x7e, 0x0f, 0xdb, 0xce, |
|
0x9e, 0xc5, 0xe8, 0xf9, 0x58, 0xc1, 0x96, 0xae, 0x8c, 0xda, 0xde, 0x3f, 0xd9, 0x62, 0xd4, 0xa1, |
|
0x68, 0xc7, 0x83, 0xc9, 0x33, 0x18, 0x47, 0xc9, 0xa3, 0x76, 0x7d, 0x6f, 0xa0, 0x3b, 0xa7, 0x6e, |
|
0x57, 0xee, 0xd1, 0xa1, 0x32, 0xa0, 0x03, 0xaa, 0x70, 0x78, 0xd7, 0xfd, 0xc4, 0x57, 0x7c, 0xc1, |
|
0x9f, 0x7c, 0x1a, 0x69, 0x13, 0xca, 0x47, 0xc4, 0x24, 0x0c, 0x1b, 0x1a, 0xb1, 0x2d, 0x6a, 0xda, |
|
0x44, 0x72, 0x01, 0x69, 0x94, 0x0e, 0x8f, 0x89, 0x6d, 0xe3, 0x01, 0xd1, 0xc8, 0x67, 0x97, 0xd8, |
|
0x0e, 0xba, 0x0d, 0x45, 0x46, 0xe9, 0xb0, 0xa3, 0xf7, 0x6b, 0x42, 0x53, 0x68, 0xad, 0xa8, 0xa5, |
|
0xe9, 0xa4, 0x11, 0x96, 0xb4, 0x82, 0xf7, 0xf0, 0xa2, 0x8f, 0x6e, 0x41, 0x71, 0xe8, 0x9f, 0xab, |
|
0x89, 0x4d, 0xa1, 0xb5, 0xa6, 0x16, 0xa7, 0x93, 0x46, 0x6e, 0x68, 0x0f, 0xb4, 0xb0, 0x8e, 0x76, |
|
0xa0, 0x40, 0x4c, 0xdb, 0x65, 0xa4, 0x96, 0xf3, 0x78, 0xb4, 0x60, 0x25, 0x7d, 0x80, 0xaa, 0x1a, |
|
0xba, 0x89, 0x69, 0xd7, 0x22, 0x56, 0x4f, 0x7b, 0x2d, 0x22, 0xbb, 0x03, 0x65, 0x72, 0xde, 0x33, |
|
0xdc, 0x3e, 0xe9, 0x84, 0xdd, 0x89, 0xcd, 0x5c, 0x6b, 0x45, 0xdb, 0x08, 0xca, 0x1a, 0xef, 0x4b, |
|
0xfa, 0x02, 0xd5, 0x63, 0xd7, 0x70, 0xf4, 0xeb, 0x8c, 0xe5, 0xfe, 0x83, 0x31, 0x06, 0x55, 0x15, |
|
0x3b, 0xbd, 0xd3, 0x04, 0xed, 0x13, 0x58, 0xe7, 0x42, 0x91, 0xbb, 0x5c, 0xab, 0xb4, 0x7f, 0x4f, |
|
0x4e, 0x7e, 0xb7, 0xf2, 0x22, 0x83, 0xba, 0x3a, 0x9d, 0x34, 0xf2, 0x7d, 0xec, 0x60, 0xad, 0xc4, |
|
0xa2, 0x5d, 0xe9, 0x1d, 0xa0, 0x37, 0x36, 0x61, 0x31, 0xb9, 0x26, 0x14, 0x5d, 0x9b, 0xb0, 0xf0, |
|
0x1d, 0xe6, 0x7c, 0x13, 0xae, 0x67, 0xd3, 0xab, 0x2f, 0x65, 0x73, 0x66, 0x27, 0x81, 0xff, 0x04, |
|
0xd6, 0x39, 0xff, 0x92, 0x76, 0x16, 0x19, 0xe6, 0xed, 0xb8, 0xd1, 0xae, 0xf4, 0x1a, 0xca, 0x87, |
|
0xba, 0x6d, 0xf1, 0x29, 0x2e, 0xed, 0xa5, 0x11, 0x22, 0xac, 0xc0, 0x4b, 0x61, 0x3a, 0x69, 0x88, |
|
0xba, 0x15, 0x00, 0x2c, 0xe9, 0x39, 0x54, 0x22, 0x56, 0xff, 0xe3, 0x47, 0x3b, 0x20, 0xea, 0x16, |
|
0x6f, 0x3c, 0xc2, 0x8b, 0xba, 0x85, 0x6e, 0x42, 0xfe, 0x94, 0xda, 0x0e, 0xff, 0xba, 0xd6, 0xfc, |
|
0x36, 0xbd, 0xb5, 0xc6, 0xff, 0x4a, 0xdf, 0x05, 0xd8, 0x7a, 0x45, 0x9c, 0x03, 0x73, 0xc0, 0xc6, |
|
0x6f, 0xb1, 0xe1, 0xce, 0x26, 0x62, 0x42, 0x09, 0x7b, 0xc5, 0xce, 0xc8, 0xab, 0x06, 0x03, 0x79, |
|
0x9c, 0x36, 0x90, 0x24, 0x0a, 0x39, 0xaa, 0x3c, 0x33, 0x1d, 0x36, 0x56, 0xcb, 0xd3, 0x49, 0x63, |
|
0x9e, 0x54, 0x03, 0x3c, 0x43, 0xd4, 0x9f, 0x40, 0x39, 0x86, 0x47, 0x15, 0xc8, 0x9d, 0x91, 0x31, |
|
0x1f, 0x52, 0x5e, 0xf3, 0x1e, 0xd1, 0x16, 0xac, 0xf8, 0xed, 0x88, 0xbc, 0xe6, 0x2f, 0x1e, 0x89, |
|
0x0f, 0x05, 0xa9, 0x0a, 0xdb, 0xb1, 0x1e, 0x82, 0x4c, 0x38, 0x80, 0x1b, 0x47, 0xc4, 0xf1, 0xbe, |
|
0xbf, 0x97, 0xa6, 0xa1, 0x9b, 0xe4, 0x29, 0x75, 0x4d, 0x27, 0xe5, 0x06, 0xe5, 0x13, 0x6f, 0x90, |
|
0xf4, 0x47, 0x80, 0x7a, 0x12, 0x47, 0x30, 0xf8, 0x6f, 0x02, 0x6c, 0xf2, 0x23, 0x94, 0x6f, 0x76, |
|
0x7a, 0xde, 0x6e, 0x30, 0xb0, 0xa3, 0xb4, 0x81, 0xa5, 0xf3, 0xc9, 0xb1, 0xba, 0x3f, 0xbb, 0xed, |
|
0xe9, 0xa4, 0xb1, 0xa8, 0xa2, 0x95, 0xd9, 0x65, 0x70, 0x5d, 0x85, 0xad, 0xa4, 0xf3, 0x59, 0x66, |
|
0xb9, 0xff, 0xab, 0x08, 0xc5, 0x43, 0x6c, 0x0e, 0xf1, 0x99, 0x8b, 0xba, 0x50, 0x9a, 0xbb, 0xbb, |
|
0x28, 0xc3, 0x05, 0xaf, 0xdf, 0x4d, 0xf7, 0x7e, 0x29, 0xb6, 0x91, 0x01, 0x95, 0x78, 0x7e, 0x22, |
|
0x25, 0xed, 0x70, 0x4a, 0xd2, 0x66, 0x52, 0x8b, 0x07, 0x6a, 0xba, 0x5a, 0x4a, 0xf4, 0x66, 0xf3, |
|
0x16, 0x8b, 0xd0, 0x2b, 0xbc, 0x25, 0x87, 0xed, 0xf2, 0x6a, 0x5d, 0x28, 0xcd, 0x45, 0x13, 0xca, |
|
0x90, 0x5f, 0xd9, 0x1d, 0xcd, 0x0b, 0x5d, 0xed, 0xe8, 0x5f, 0xd4, 0x3e, 0xc2, 0x6a, 0x98, 0x74, |
|
0x28, 0xf5, 0x50, 0x2c, 0x61, 0xeb, 0xad, 0xeb, 0x81, 0x33, 0x33, 0x1b, 0x97, 0x62, 0x03, 0xdd, |
|
0xcf, 0x92, 0x70, 0xf5, 0xbd, 0x25, 0xd1, 0x81, 0xda, 0x57, 0x40, 0x8b, 0xf7, 0x1e, 0xb5, 0xb3, |
|
0x64, 0x84, 0xaf, 0xbb, 0x9f, 0x3d, 0x56, 0xd4, 0xca, 0x8f, 0x8b, 0x5d, 0xe1, 0xe7, 0xc5, 0xae, |
|
0xf0, 0xfb, 0x62, 0x57, 0x78, 0x2f, 0x8e, 0xda, 0xdd, 0x02, 0xff, 0x21, 0xf5, 0xe0, 0x6f, 0x00, |
|
0x00, 0x00, 0xff, 0xff, 0x01, 0xab, 0x0b, 0xee, 0xc4, 0x09, 0x00, 0x00, |
|
}
|
|
|