bac99df

分支 (2)

提交

管理

管理

master

develop

bac99df

micro
/
cluster
/
protos.rpc.go

// Code generated by protoc-gen-rpc-go. DO NOT EDIT IT!!!
// source: protos.proto

package cluster

import (
	json "encoding/json"
	fmt "fmt"
	math "math"
	sync "sync"
	time "time"

	actor1 "gitee.com/nggs/micro/actor"
	actor "github.com/AsynkronIT/protoactor-go/actor"
	proto "github.com/gogo/protobuf/proto"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// enum [ErrorCode] begin

var ErrorCode_Slice = []int32{
	0,
	1,
	2,
	3,
	4,
	5,
	6,
	7,
}

func ErrorCode_Len() int {
	return len(ErrorCode_Slice)
}

func Check_ErrorCode_I(value int32) bool {
	if _, ok := ErrorCode_name[value]; ok && value != 0 {
		return true
	}
	return false
}

func Check_ErrorCode(value ErrorCode) bool {
	return Check_ErrorCode_I(int32(value))
}

func Each_ErrorCode(f func(ErrorCode) bool) {
	for _, value := range ErrorCode_Slice {
		if !f(ErrorCode(value)) {
			break
		}
	}
}

func Each_ErrorCode_I(f func(int32) bool) {
	for _, value := range ErrorCode_Slice {
		if !f(value) {
			break
		}
	}
}

// enum [ErrorCode] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [Error] begin
func (m *Error) ResetEx() {

	m.Code = 0

	m.Message = ""

}

func (m Error) Clone() *Error {
	n, ok := g_Error_Pool.Get().(*Error)
	if !ok || n == nil {
		n = &Error{}
	}

	n.Code = m.Code

	n.Message = m.Message

	return n
}

func Clone_Error_Slice(dst []*Error, src []*Error) []*Error {
	for _, i := range dst {
		Put_Error(i)
	}
	if len(src) > 0 {
		dst = make([]*Error, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*Error{}
		dst = nil
	}
	return dst
}

func (m Error) JsonString() string {
	ba, _ := json.Marshal(m)
	return "Error:" + string(ba)
}

func (Error) CanIgnore() bool {
	return false
}

func New_Error() *Error {
	m := &Error{}
	return m
}

var g_Error_Pool = sync.Pool{}

func Get_Error() *Error {
	m, ok := g_Error_Pool.Get().(*Error)
	if !ok {
		m = New_Error()
	} else {
		if m == nil {
			m = New_Error()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_Error(i interface{}) {
	if m, ok := i.(*Error); ok && m != nil {
		g_Error_Pool.Put(i)
	}
}

// message [Error] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [C2S_GlobalConfig] begin
func (m *C2S_GlobalConfig) ResetEx() {

}

func (m C2S_GlobalConfig) Clone() *C2S_GlobalConfig {
	n, ok := g_C2S_GlobalConfig_Pool.Get().(*C2S_GlobalConfig)
	if !ok || n == nil {
		n = &C2S_GlobalConfig{}
	}

	return n
}

func Clone_C2S_GlobalConfig_Slice(dst []*C2S_GlobalConfig, src []*C2S_GlobalConfig) []*C2S_GlobalConfig {
	for _, i := range dst {
		Put_C2S_GlobalConfig(i)
	}
	if len(src) > 0 {
		dst = make([]*C2S_GlobalConfig, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*C2S_GlobalConfig{}
		dst = nil
	}
	return dst
}

func (m C2S_GlobalConfig) JsonString() string {
	ba, _ := json.Marshal(m)
	return "C2S_GlobalConfig:" + string(ba)
}

func Request_S2C_GlobalConfig(pid *actor.PID, send *C2S_GlobalConfig) (*S2C_GlobalConfig, error) {
	return Request_S2C_GlobalConfig_T(pid, send, 10000*time.Millisecond)
}

func Request_S2C_GlobalConfig_T(pid *actor.PID, send *C2S_GlobalConfig, timeout time.Duration) (*S2C_GlobalConfig, error) {
	if pid == nil {
		return nil, fmt.Errorf("pid is nil")
	}
	f := actor1.RootContext.RequestFuture(pid, send, timeout)
	iRecv, err := f.Result()
	if err != nil {
		return nil, err
	}
	recv, ok := iRecv.(*S2C_GlobalConfig)
	if !ok {
		return nil, fmt.Errorf("recv %#v is not S2C_GlobalConfig", recv)
	}
	return recv, nil
}

func (C2S_GlobalConfig) CanIgnore() bool {
	return false
}

func New_C2S_GlobalConfig() *C2S_GlobalConfig {
	m := &C2S_GlobalConfig{}
	return m
}

var g_C2S_GlobalConfig_Pool = sync.Pool{}

func Get_C2S_GlobalConfig() *C2S_GlobalConfig {
	m, ok := g_C2S_GlobalConfig_Pool.Get().(*C2S_GlobalConfig)
	if !ok {
		m = New_C2S_GlobalConfig()
	} else {
		if m == nil {
			m = New_C2S_GlobalConfig()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_C2S_GlobalConfig(i interface{}) {
	if m, ok := i.(*C2S_GlobalConfig); ok && m != nil {
		g_C2S_GlobalConfig_Pool.Put(i)
	}
}

// message [C2S_GlobalConfig] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [S2C_GlobalConfig] begin
func (m *S2C_GlobalConfig) ResetEx() {

	m.ConfigData = nil

}

func (m S2C_GlobalConfig) Clone() *S2C_GlobalConfig {
	n, ok := g_S2C_GlobalConfig_Pool.Get().(*S2C_GlobalConfig)
	if !ok || n == nil {
		n = &S2C_GlobalConfig{}
	}

	if len(m.ConfigData) > 0 {
		n.ConfigData = make([]byte, len(m.ConfigData))
		copy(n.ConfigData, m.ConfigData)
	} else {
		//n.ConfigData = []byte{}
		n.ConfigData = nil
	}

	return n
}

func Clone_S2C_GlobalConfig_Slice(dst []*S2C_GlobalConfig, src []*S2C_GlobalConfig) []*S2C_GlobalConfig {
	for _, i := range dst {
		Put_S2C_GlobalConfig(i)
	}
	if len(src) > 0 {
		dst = make([]*S2C_GlobalConfig, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*S2C_GlobalConfig{}
		dst = nil
	}
	return dst
}

func (m S2C_GlobalConfig) JsonString() string {
	ba, _ := json.Marshal(m)
	return "S2C_GlobalConfig:" + string(ba)
}

func (S2C_GlobalConfig) CanIgnore() bool {
	return false
}

func New_S2C_GlobalConfig() *S2C_GlobalConfig {
	m := &S2C_GlobalConfig{}
	return m
}

var g_S2C_GlobalConfig_Pool = sync.Pool{}

func Get_S2C_GlobalConfig() *S2C_GlobalConfig {
	m, ok := g_S2C_GlobalConfig_Pool.Get().(*S2C_GlobalConfig)
	if !ok {
		m = New_S2C_GlobalConfig()
	} else {
		if m == nil {
			m = New_S2C_GlobalConfig()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_S2C_GlobalConfig(i interface{}) {
	if m, ok := i.(*S2C_GlobalConfig); ok && m != nil {
		g_S2C_GlobalConfig_Pool.Put(i)
	}
}

// message [S2C_GlobalConfig] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [C2S_ServiceGlobalConfig] begin
func (m *C2S_ServiceGlobalConfig) ResetEx() {

	m.Name = ""

}

func (m C2S_ServiceGlobalConfig) Clone() *C2S_ServiceGlobalConfig {
	n, ok := g_C2S_ServiceGlobalConfig_Pool.Get().(*C2S_ServiceGlobalConfig)
	if !ok || n == nil {
		n = &C2S_ServiceGlobalConfig{}
	}

	n.Name = m.Name

	return n
}

func Clone_C2S_ServiceGlobalConfig_Slice(dst []*C2S_ServiceGlobalConfig, src []*C2S_ServiceGlobalConfig) []*C2S_ServiceGlobalConfig {
	for _, i := range dst {
		Put_C2S_ServiceGlobalConfig(i)
	}
	if len(src) > 0 {
		dst = make([]*C2S_ServiceGlobalConfig, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*C2S_ServiceGlobalConfig{}
		dst = nil
	}
	return dst
}

func (m C2S_ServiceGlobalConfig) JsonString() string {
	ba, _ := json.Marshal(m)
	return "C2S_ServiceGlobalConfig:" + string(ba)
}

func Request_S2C_ServiceGlobalConfig(pid *actor.PID, send *C2S_ServiceGlobalConfig) (*S2C_ServiceGlobalConfig, error) {
	return Request_S2C_ServiceGlobalConfig_T(pid, send, 10000*time.Millisecond)
}

func Request_S2C_ServiceGlobalConfig_T(pid *actor.PID, send *C2S_ServiceGlobalConfig, timeout time.Duration) (*S2C_ServiceGlobalConfig, error) {
	if pid == nil {
		return nil, fmt.Errorf("pid is nil")
	}
	f := actor1.RootContext.RequestFuture(pid, send, timeout)
	iRecv, err := f.Result()
	if err != nil {
		return nil, err
	}
	recv, ok := iRecv.(*S2C_ServiceGlobalConfig)
	if !ok {
		return nil, fmt.Errorf("recv %#v is not S2C_ServiceGlobalConfig", recv)
	}
	return recv, nil
}

func (C2S_ServiceGlobalConfig) CanIgnore() bool {
	return false
}

func New_C2S_ServiceGlobalConfig() *C2S_ServiceGlobalConfig {
	m := &C2S_ServiceGlobalConfig{}
	return m
}

var g_C2S_ServiceGlobalConfig_Pool = sync.Pool{}

func Get_C2S_ServiceGlobalConfig() *C2S_ServiceGlobalConfig {
	m, ok := g_C2S_ServiceGlobalConfig_Pool.Get().(*C2S_ServiceGlobalConfig)
	if !ok {
		m = New_C2S_ServiceGlobalConfig()
	} else {
		if m == nil {
			m = New_C2S_ServiceGlobalConfig()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_C2S_ServiceGlobalConfig(i interface{}) {
	if m, ok := i.(*C2S_ServiceGlobalConfig); ok && m != nil {
		g_C2S_ServiceGlobalConfig_Pool.Put(i)
	}
}

// message [C2S_ServiceGlobalConfig] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [S2C_ServiceGlobalConfig] begin
func (m *S2C_ServiceGlobalConfig) ResetEx() {

	if m.Err != nil {
		m.Err.ResetEx()
	} else {

		m.Err = Get_Error()

	}

	m.ConfigData = nil

}

func (m S2C_ServiceGlobalConfig) Clone() *S2C_ServiceGlobalConfig {
	n, ok := g_S2C_ServiceGlobalConfig_Pool.Get().(*S2C_ServiceGlobalConfig)
	if !ok || n == nil {
		n = &S2C_ServiceGlobalConfig{}
	}

	if m.Err != nil {
		n.Err = m.Err.Clone()
	}

	if len(m.ConfigData) > 0 {
		n.ConfigData = make([]byte, len(m.ConfigData))
		copy(n.ConfigData, m.ConfigData)
	} else {
		//n.ConfigData = []byte{}
		n.ConfigData = nil
	}

	return n
}

func Clone_S2C_ServiceGlobalConfig_Slice(dst []*S2C_ServiceGlobalConfig, src []*S2C_ServiceGlobalConfig) []*S2C_ServiceGlobalConfig {
	for _, i := range dst {
		Put_S2C_ServiceGlobalConfig(i)
	}
	if len(src) > 0 {
		dst = make([]*S2C_ServiceGlobalConfig, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*S2C_ServiceGlobalConfig{}
		dst = nil
	}
	return dst
}

func (m S2C_ServiceGlobalConfig) JsonString() string {
	ba, _ := json.Marshal(m)
	return "S2C_ServiceGlobalConfig:" + string(ba)
}

func (S2C_ServiceGlobalConfig) CanIgnore() bool {
	return false
}

func New_S2C_ServiceGlobalConfig() *S2C_ServiceGlobalConfig {
	m := &S2C_ServiceGlobalConfig{

		Err: New_Error(),
	}
	return m
}

var g_S2C_ServiceGlobalConfig_Pool = sync.Pool{}

func Get_S2C_ServiceGlobalConfig() *S2C_ServiceGlobalConfig {
	m, ok := g_S2C_ServiceGlobalConfig_Pool.Get().(*S2C_ServiceGlobalConfig)
	if !ok {
		m = New_S2C_ServiceGlobalConfig()
	} else {
		if m == nil {
			m = New_S2C_ServiceGlobalConfig()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_S2C_ServiceGlobalConfig(i interface{}) {
	if m, ok := i.(*S2C_ServiceGlobalConfig); ok && m != nil {
		g_S2C_ServiceGlobalConfig_Pool.Put(i)
	}
}

// message [S2C_ServiceGlobalConfig] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [ServiceInstance] begin
func (m *ServiceInstance) ResetEx() {

	if m.PID != nil {
		m.PID.ResetEx()
	} else {

		m.PID = actor.Get_PID()

	}

	m.PprofAddr = ""

	m.Extra = nil

}

func (m ServiceInstance) Clone() *ServiceInstance {
	n, ok := g_ServiceInstance_Pool.Get().(*ServiceInstance)
	if !ok || n == nil {
		n = &ServiceInstance{}
	}

	if m.PID != nil {
		n.PID = m.PID.Clone()
	}

	n.PprofAddr = m.PprofAddr

	if len(m.Extra) > 0 {
		n.Extra = make([]byte, len(m.Extra))
		copy(n.Extra, m.Extra)
	} else {
		//n.Extra = []byte{}
		n.Extra = nil
	}

	return n
}

func Clone_ServiceInstance_Slice(dst []*ServiceInstance, src []*ServiceInstance) []*ServiceInstance {
	for _, i := range dst {
		Put_ServiceInstance(i)
	}
	if len(src) > 0 {
		dst = make([]*ServiceInstance, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*ServiceInstance{}
		dst = nil
	}
	return dst
}

func (m ServiceInstance) JsonString() string {
	ba, _ := json.Marshal(m)
	return "ServiceInstance:" + string(ba)
}

func (ServiceInstance) CanIgnore() bool {
	return false
}

func New_ServiceInstance() *ServiceInstance {
	m := &ServiceInstance{

		PID: actor.New_PID(),
	}
	return m
}

var g_ServiceInstance_Pool = sync.Pool{}

func Get_ServiceInstance() *ServiceInstance {
	m, ok := g_ServiceInstance_Pool.Get().(*ServiceInstance)
	if !ok {
		m = New_ServiceInstance()
	} else {
		if m == nil {
			m = New_ServiceInstance()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_ServiceInstance(i interface{}) {
	if m, ok := i.(*ServiceInstance); ok && m != nil {
		g_ServiceInstance_Pool.Put(i)
	}
}

// message [ServiceInstance] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [ServiceInfo] begin
func (m *ServiceInfo) ResetEx() {

	m.ID = 0

	m.ConfigData = nil

	if m.Instance != nil {
		m.Instance.ResetEx()
	} else {

		m.Instance = Get_ServiceInstance()

	}

	m.Payload = 0

}

func (m ServiceInfo) Clone() *ServiceInfo {
	n, ok := g_ServiceInfo_Pool.Get().(*ServiceInfo)
	if !ok || n == nil {
		n = &ServiceInfo{}
	}

	n.ID = m.ID

	if len(m.ConfigData) > 0 {
		n.ConfigData = make([]byte, len(m.ConfigData))
		copy(n.ConfigData, m.ConfigData)
	} else {
		//n.ConfigData = []byte{}
		n.ConfigData = nil
	}

	if m.Instance != nil {
		n.Instance = m.Instance.Clone()
	}

	n.Payload = m.Payload

	return n
}

func Clone_ServiceInfo_Slice(dst []*ServiceInfo, src []*ServiceInfo) []*ServiceInfo {
	for _, i := range dst {
		Put_ServiceInfo(i)
	}
	if len(src) > 0 {
		dst = make([]*ServiceInfo, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*ServiceInfo{}
		dst = nil
	}
	return dst
}

func (m ServiceInfo) JsonString() string {
	ba, _ := json.Marshal(m)
	return "ServiceInfo:" + string(ba)
}

func (ServiceInfo) CanIgnore() bool {
	return false
}

func New_ServiceInfo() *ServiceInfo {
	m := &ServiceInfo{

		Instance: New_ServiceInstance(),
	}
	return m
}

var g_ServiceInfo_Pool = sync.Pool{}

func Get_ServiceInfo() *ServiceInfo {
	m, ok := g_ServiceInfo_Pool.Get().(*ServiceInfo)
	if !ok {
		m = New_ServiceInfo()
	} else {
		if m == nil {
			m = New_ServiceInfo()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_ServiceInfo(i interface{}) {
	if m, ok := i.(*ServiceInfo); ok && m != nil {
		g_ServiceInfo_Pool.Put(i)
	}
}

// message [ServiceInfo] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [C2S_ServiceInfo] begin
func (m *C2S_ServiceInfo) ResetEx() {

	m.Name = ""

	m.ID = 0

}

func (m C2S_ServiceInfo) Clone() *C2S_ServiceInfo {
	n, ok := g_C2S_ServiceInfo_Pool.Get().(*C2S_ServiceInfo)
	if !ok || n == nil {
		n = &C2S_ServiceInfo{}
	}

	n.Name = m.Name

	n.ID = m.ID

	return n
}

func Clone_C2S_ServiceInfo_Slice(dst []*C2S_ServiceInfo, src []*C2S_ServiceInfo) []*C2S_ServiceInfo {
	for _, i := range dst {
		Put_C2S_ServiceInfo(i)
	}
	if len(src) > 0 {
		dst = make([]*C2S_ServiceInfo, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*C2S_ServiceInfo{}
		dst = nil
	}
	return dst
}

func (m C2S_ServiceInfo) JsonString() string {
	ba, _ := json.Marshal(m)
	return "C2S_ServiceInfo:" + string(ba)
}

func Request_S2C_ServiceInfo(pid *actor.PID, send *C2S_ServiceInfo) (*S2C_ServiceInfo, error) {
	return Request_S2C_ServiceInfo_T(pid, send, 10000*time.Millisecond)
}

func Request_S2C_ServiceInfo_T(pid *actor.PID, send *C2S_ServiceInfo, timeout time.Duration) (*S2C_ServiceInfo, error) {
	if pid == nil {
		return nil, fmt.Errorf("pid is nil")
	}
	f := actor1.RootContext.RequestFuture(pid, send, timeout)
	iRecv, err := f.Result()
	if err != nil {
		return nil, err
	}
	recv, ok := iRecv.(*S2C_ServiceInfo)
	if !ok {
		return nil, fmt.Errorf("recv %#v is not S2C_ServiceInfo", recv)
	}
	return recv, nil
}

func (C2S_ServiceInfo) CanIgnore() bool {
	return false
}

func New_C2S_ServiceInfo() *C2S_ServiceInfo {
	m := &C2S_ServiceInfo{}
	return m
}

var g_C2S_ServiceInfo_Pool = sync.Pool{}

func Get_C2S_ServiceInfo() *C2S_ServiceInfo {
	m, ok := g_C2S_ServiceInfo_Pool.Get().(*C2S_ServiceInfo)
	if !ok {
		m = New_C2S_ServiceInfo()
	} else {
		if m == nil {
			m = New_C2S_ServiceInfo()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_C2S_ServiceInfo(i interface{}) {
	if m, ok := i.(*C2S_ServiceInfo); ok && m != nil {
		g_C2S_ServiceInfo_Pool.Put(i)
	}
}

// message [C2S_ServiceInfo] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [S2C_ServiceInfo] begin
func (m *S2C_ServiceInfo) ResetEx() {

	if m.Err != nil {
		m.Err.ResetEx()
	} else {

		m.Err = Get_Error()

	}

	if m.Info != nil {
		m.Info.ResetEx()
	} else {

		m.Info = Get_ServiceInfo()

	}

}

func (m S2C_ServiceInfo) Clone() *S2C_ServiceInfo {
	n, ok := g_S2C_ServiceInfo_Pool.Get().(*S2C_ServiceInfo)
	if !ok || n == nil {
		n = &S2C_ServiceInfo{}
	}

	if m.Err != nil {
		n.Err = m.Err.Clone()
	}

	if m.Info != nil {
		n.Info = m.Info.Clone()
	}

	return n
}

func Clone_S2C_ServiceInfo_Slice(dst []*S2C_ServiceInfo, src []*S2C_ServiceInfo) []*S2C_ServiceInfo {
	for _, i := range dst {
		Put_S2C_ServiceInfo(i)
	}
	if len(src) > 0 {
		dst = make([]*S2C_ServiceInfo, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*S2C_ServiceInfo{}
		dst = nil
	}
	return dst
}

func (m S2C_ServiceInfo) JsonString() string {
	ba, _ := json.Marshal(m)
	return "S2C_ServiceInfo:" + string(ba)
}

func (S2C_ServiceInfo) CanIgnore() bool {
	return false
}

func New_S2C_ServiceInfo() *S2C_ServiceInfo {
	m := &S2C_ServiceInfo{

		Err: New_Error(),

		Info: New_ServiceInfo(),
	}
	return m
}

var g_S2C_ServiceInfo_Pool = sync.Pool{}

func Get_S2C_ServiceInfo() *S2C_ServiceInfo {
	m, ok := g_S2C_ServiceInfo_Pool.Get().(*S2C_ServiceInfo)
	if !ok {
		m = New_S2C_ServiceInfo()
	} else {
		if m == nil {
			m = New_S2C_ServiceInfo()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_S2C_ServiceInfo(i interface{}) {
	if m, ok := i.(*S2C_ServiceInfo); ok && m != nil {
		g_S2C_ServiceInfo_Pool.Put(i)
	}
}

// message [S2C_ServiceInfo] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [C2S_ServiceInstance] begin
func (m *C2S_ServiceInstance) ResetEx() {

	m.Name = ""

	m.ID = 0

}

func (m C2S_ServiceInstance) Clone() *C2S_ServiceInstance {
	n, ok := g_C2S_ServiceInstance_Pool.Get().(*C2S_ServiceInstance)
	if !ok || n == nil {
		n = &C2S_ServiceInstance{}
	}

	n.Name = m.Name

	n.ID = m.ID

	return n
}

func Clone_C2S_ServiceInstance_Slice(dst []*C2S_ServiceInstance, src []*C2S_ServiceInstance) []*C2S_ServiceInstance {
	for _, i := range dst {
		Put_C2S_ServiceInstance(i)
	}
	if len(src) > 0 {
		dst = make([]*C2S_ServiceInstance, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*C2S_ServiceInstance{}
		dst = nil
	}
	return dst
}

func (m C2S_ServiceInstance) JsonString() string {
	ba, _ := json.Marshal(m)
	return "C2S_ServiceInstance:" + string(ba)
}

func Request_S2C_ServiceInstance(pid *actor.PID, send *C2S_ServiceInstance) (*S2C_ServiceInstance, error) {
	return Request_S2C_ServiceInstance_T(pid, send, 10000*time.Millisecond)
}

func Request_S2C_ServiceInstance_T(pid *actor.PID, send *C2S_ServiceInstance, timeout time.Duration) (*S2C_ServiceInstance, error) {
	if pid == nil {
		return nil, fmt.Errorf("pid is nil")
	}
	f := actor1.RootContext.RequestFuture(pid, send, timeout)
	iRecv, err := f.Result()
	if err != nil {
		return nil, err
	}
	recv, ok := iRecv.(*S2C_ServiceInstance)
	if !ok {
		return nil, fmt.Errorf("recv %#v is not S2C_ServiceInstance", recv)
	}
	return recv, nil
}

func (C2S_ServiceInstance) CanIgnore() bool {
	return false
}

func New_C2S_ServiceInstance() *C2S_ServiceInstance {
	m := &C2S_ServiceInstance{}
	return m
}

var g_C2S_ServiceInstance_Pool = sync.Pool{}

func Get_C2S_ServiceInstance() *C2S_ServiceInstance {
	m, ok := g_C2S_ServiceInstance_Pool.Get().(*C2S_ServiceInstance)
	if !ok {
		m = New_C2S_ServiceInstance()
	} else {
		if m == nil {
			m = New_C2S_ServiceInstance()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_C2S_ServiceInstance(i interface{}) {
	if m, ok := i.(*C2S_ServiceInstance); ok && m != nil {
		g_C2S_ServiceInstance_Pool.Put(i)
	}
}

// message [C2S_ServiceInstance] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [S2C_ServiceInstance] begin
func (m *S2C_ServiceInstance) ResetEx() {

	if m.Err != nil {
		m.Err.ResetEx()
	} else {

		m.Err = Get_Error()

	}

	if m.Instance != nil {
		m.Instance.ResetEx()
	} else {

		m.Instance = Get_ServiceInstance()

	}

}

func (m S2C_ServiceInstance) Clone() *S2C_ServiceInstance {
	n, ok := g_S2C_ServiceInstance_Pool.Get().(*S2C_ServiceInstance)
	if !ok || n == nil {
		n = &S2C_ServiceInstance{}
	}

	if m.Err != nil {
		n.Err = m.Err.Clone()
	}

	if m.Instance != nil {
		n.Instance = m.Instance.Clone()
	}

	return n
}

func Clone_S2C_ServiceInstance_Slice(dst []*S2C_ServiceInstance, src []*S2C_ServiceInstance) []*S2C_ServiceInstance {
	for _, i := range dst {
		Put_S2C_ServiceInstance(i)
	}
	if len(src) > 0 {
		dst = make([]*S2C_ServiceInstance, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*S2C_ServiceInstance{}
		dst = nil
	}
	return dst
}

func (m S2C_ServiceInstance) JsonString() string {
	ba, _ := json.Marshal(m)
	return "S2C_ServiceInstance:" + string(ba)
}

func (S2C_ServiceInstance) CanIgnore() bool {
	return false
}

func New_S2C_ServiceInstance() *S2C_ServiceInstance {
	m := &S2C_ServiceInstance{

		Err: New_Error(),

		Instance: New_ServiceInstance(),
	}
	return m
}

var g_S2C_ServiceInstance_Pool = sync.Pool{}

func Get_S2C_ServiceInstance() *S2C_ServiceInstance {
	m, ok := g_S2C_ServiceInstance_Pool.Get().(*S2C_ServiceInstance)
	if !ok {
		m = New_S2C_ServiceInstance()
	} else {
		if m == nil {
			m = New_S2C_ServiceInstance()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_S2C_ServiceInstance(i interface{}) {
	if m, ok := i.(*S2C_ServiceInstance); ok && m != nil {
		g_S2C_ServiceInstance_Pool.Put(i)
	}
}

// message [S2C_ServiceInstance] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [C2S_PutServiceInstance] begin
func (m *C2S_PutServiceInstance) ResetEx() {

	m.Name = ""

	m.ID = 0

	if m.Instance != nil {
		m.Instance.ResetEx()
	} else {

		m.Instance = Get_ServiceInstance()

	}

}

func (m C2S_PutServiceInstance) Clone() *C2S_PutServiceInstance {
	n, ok := g_C2S_PutServiceInstance_Pool.Get().(*C2S_PutServiceInstance)
	if !ok || n == nil {
		n = &C2S_PutServiceInstance{}
	}

	n.Name = m.Name

	n.ID = m.ID

	if m.Instance != nil {
		n.Instance = m.Instance.Clone()
	}

	return n
}

func Clone_C2S_PutServiceInstance_Slice(dst []*C2S_PutServiceInstance, src []*C2S_PutServiceInstance) []*C2S_PutServiceInstance {
	for _, i := range dst {
		Put_C2S_PutServiceInstance(i)
	}
	if len(src) > 0 {
		dst = make([]*C2S_PutServiceInstance, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*C2S_PutServiceInstance{}
		dst = nil
	}
	return dst
}

func (m C2S_PutServiceInstance) JsonString() string {
	ba, _ := json.Marshal(m)
	return "C2S_PutServiceInstance:" + string(ba)
}

func Request_S2C_PutServiceInstance(pid *actor.PID, send *C2S_PutServiceInstance) (*S2C_PutServiceInstance, error) {
	return Request_S2C_PutServiceInstance_T(pid, send, 10000*time.Millisecond)
}

func Request_S2C_PutServiceInstance_T(pid *actor.PID, send *C2S_PutServiceInstance, timeout time.Duration) (*S2C_PutServiceInstance, error) {
	if pid == nil {
		return nil, fmt.Errorf("pid is nil")
	}
	f := actor1.RootContext.RequestFuture(pid, send, timeout)
	iRecv, err := f.Result()
	if err != nil {
		return nil, err
	}
	recv, ok := iRecv.(*S2C_PutServiceInstance)
	if !ok {
		return nil, fmt.Errorf("recv %#v is not S2C_PutServiceInstance", recv)
	}
	return recv, nil
}

func (C2S_PutServiceInstance) CanIgnore() bool {
	return false
}

func New_C2S_PutServiceInstance() *C2S_PutServiceInstance {
	m := &C2S_PutServiceInstance{

		Instance: New_ServiceInstance(),
	}
	return m
}

var g_C2S_PutServiceInstance_Pool = sync.Pool{}

func Get_C2S_PutServiceInstance() *C2S_PutServiceInstance {
	m, ok := g_C2S_PutServiceInstance_Pool.Get().(*C2S_PutServiceInstance)
	if !ok {
		m = New_C2S_PutServiceInstance()
	} else {
		if m == nil {
			m = New_C2S_PutServiceInstance()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_C2S_PutServiceInstance(i interface{}) {
	if m, ok := i.(*C2S_PutServiceInstance); ok && m != nil {
		g_C2S_PutServiceInstance_Pool.Put(i)
	}
}

// message [C2S_PutServiceInstance] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [S2C_PutServiceInstance] begin
func (m *S2C_PutServiceInstance) ResetEx() {

	if m.Err != nil {
		m.Err.ResetEx()
	} else {

		m.Err = Get_Error()

	}

}

func (m S2C_PutServiceInstance) Clone() *S2C_PutServiceInstance {
	n, ok := g_S2C_PutServiceInstance_Pool.Get().(*S2C_PutServiceInstance)
	if !ok || n == nil {
		n = &S2C_PutServiceInstance{}
	}

	if m.Err != nil {
		n.Err = m.Err.Clone()
	}

	return n
}

func Clone_S2C_PutServiceInstance_Slice(dst []*S2C_PutServiceInstance, src []*S2C_PutServiceInstance) []*S2C_PutServiceInstance {
	for _, i := range dst {
		Put_S2C_PutServiceInstance(i)
	}
	if len(src) > 0 {
		dst = make([]*S2C_PutServiceInstance, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*S2C_PutServiceInstance{}
		dst = nil
	}
	return dst
}

func (m S2C_PutServiceInstance) JsonString() string {
	ba, _ := json.Marshal(m)
	return "S2C_PutServiceInstance:" + string(ba)
}

func (S2C_PutServiceInstance) CanIgnore() bool {
	return false
}

func New_S2C_PutServiceInstance() *S2C_PutServiceInstance {
	m := &S2C_PutServiceInstance{

		Err: New_Error(),
	}
	return m
}

var g_S2C_PutServiceInstance_Pool = sync.Pool{}

func Get_S2C_PutServiceInstance() *S2C_PutServiceInstance {
	m, ok := g_S2C_PutServiceInstance_Pool.Get().(*S2C_PutServiceInstance)
	if !ok {
		m = New_S2C_PutServiceInstance()
	} else {
		if m == nil {
			m = New_S2C_PutServiceInstance()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_S2C_PutServiceInstance(i interface{}) {
	if m, ok := i.(*S2C_PutServiceInstance); ok && m != nil {
		g_S2C_PutServiceInstance_Pool.Put(i)
	}
}

// message [S2C_PutServiceInstance] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [C2S_TryLockServicePosition] begin
func (m *C2S_TryLockServicePosition) ResetEx() {

	m.Name = ""

	m.ID = 0

	if m.Instance != nil {
		m.Instance.ResetEx()
	} else {

		m.Instance = Get_ServiceInstance()

	}

}

func (m C2S_TryLockServicePosition) Clone() *C2S_TryLockServicePosition {
	n, ok := g_C2S_TryLockServicePosition_Pool.Get().(*C2S_TryLockServicePosition)
	if !ok || n == nil {
		n = &C2S_TryLockServicePosition{}
	}

	n.Name = m.Name

	n.ID = m.ID

	if m.Instance != nil {
		n.Instance = m.Instance.Clone()
	}

	return n
}

func Clone_C2S_TryLockServicePosition_Slice(dst []*C2S_TryLockServicePosition, src []*C2S_TryLockServicePosition) []*C2S_TryLockServicePosition {
	for _, i := range dst {
		Put_C2S_TryLockServicePosition(i)
	}
	if len(src) > 0 {
		dst = make([]*C2S_TryLockServicePosition, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*C2S_TryLockServicePosition{}
		dst = nil
	}
	return dst
}

func (m C2S_TryLockServicePosition) JsonString() string {
	ba, _ := json.Marshal(m)
	return "C2S_TryLockServicePosition:" + string(ba)
}

func Request_S2C_TryLockServicePosition(pid *actor.PID, send *C2S_TryLockServicePosition) (*S2C_TryLockServicePosition, error) {
	return Request_S2C_TryLockServicePosition_T(pid, send, 10000*time.Millisecond)
}

func Request_S2C_TryLockServicePosition_T(pid *actor.PID, send *C2S_TryLockServicePosition, timeout time.Duration) (*S2C_TryLockServicePosition, error) {
	if pid == nil {
		return nil, fmt.Errorf("pid is nil")
	}
	f := actor1.RootContext.RequestFuture(pid, send, timeout)
	iRecv, err := f.Result()
	if err != nil {
		return nil, err
	}
	recv, ok := iRecv.(*S2C_TryLockServicePosition)
	if !ok {
		return nil, fmt.Errorf("recv %#v is not S2C_TryLockServicePosition", recv)
	}
	return recv, nil
}

func (C2S_TryLockServicePosition) CanIgnore() bool {
	return false
}

func New_C2S_TryLockServicePosition() *C2S_TryLockServicePosition {
	m := &C2S_TryLockServicePosition{

		Instance: New_ServiceInstance(),
	}
	return m
}

var g_C2S_TryLockServicePosition_Pool = sync.Pool{}

func Get_C2S_TryLockServicePosition() *C2S_TryLockServicePosition {
	m, ok := g_C2S_TryLockServicePosition_Pool.Get().(*C2S_TryLockServicePosition)
	if !ok {
		m = New_C2S_TryLockServicePosition()
	} else {
		if m == nil {
			m = New_C2S_TryLockServicePosition()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_C2S_TryLockServicePosition(i interface{}) {
	if m, ok := i.(*C2S_TryLockServicePosition); ok && m != nil {
		g_C2S_TryLockServicePosition_Pool.Put(i)
	}
}

// message [C2S_TryLockServicePosition] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [S2C_TryLockServicePosition] begin
func (m *S2C_TryLockServicePosition) ResetEx() {

	if m.Err != nil {
		m.Err.ResetEx()
	} else {

		m.Err = Get_Error()

	}

}

func (m S2C_TryLockServicePosition) Clone() *S2C_TryLockServicePosition {
	n, ok := g_S2C_TryLockServicePosition_Pool.Get().(*S2C_TryLockServicePosition)
	if !ok || n == nil {
		n = &S2C_TryLockServicePosition{}
	}

	if m.Err != nil {
		n.Err = m.Err.Clone()
	}

	return n
}

func Clone_S2C_TryLockServicePosition_Slice(dst []*S2C_TryLockServicePosition, src []*S2C_TryLockServicePosition) []*S2C_TryLockServicePosition {
	for _, i := range dst {
		Put_S2C_TryLockServicePosition(i)
	}
	if len(src) > 0 {
		dst = make([]*S2C_TryLockServicePosition, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*S2C_TryLockServicePosition{}
		dst = nil
	}
	return dst
}

func (m S2C_TryLockServicePosition) JsonString() string {
	ba, _ := json.Marshal(m)
	return "S2C_TryLockServicePosition:" + string(ba)
}

func (S2C_TryLockServicePosition) CanIgnore() bool {
	return false
}

func New_S2C_TryLockServicePosition() *S2C_TryLockServicePosition {
	m := &S2C_TryLockServicePosition{

		Err: New_Error(),
	}
	return m
}

var g_S2C_TryLockServicePosition_Pool = sync.Pool{}

func Get_S2C_TryLockServicePosition() *S2C_TryLockServicePosition {
	m, ok := g_S2C_TryLockServicePosition_Pool.Get().(*S2C_TryLockServicePosition)
	if !ok {
		m = New_S2C_TryLockServicePosition()
	} else {
		if m == nil {
			m = New_S2C_TryLockServicePosition()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_S2C_TryLockServicePosition(i interface{}) {
	if m, ok := i.(*S2C_TryLockServicePosition); ok && m != nil {
		g_S2C_TryLockServicePosition_Pool.Put(i)
	}
}

// message [S2C_TryLockServicePosition] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [C2S_ServicePayload] begin
func (m *C2S_ServicePayload) ResetEx() {

	m.Name = ""

	m.ID = 0

}

func (m C2S_ServicePayload) Clone() *C2S_ServicePayload {
	n, ok := g_C2S_ServicePayload_Pool.Get().(*C2S_ServicePayload)
	if !ok || n == nil {
		n = &C2S_ServicePayload{}
	}

	n.Name = m.Name

	n.ID = m.ID

	return n
}

func Clone_C2S_ServicePayload_Slice(dst []*C2S_ServicePayload, src []*C2S_ServicePayload) []*C2S_ServicePayload {
	for _, i := range dst {
		Put_C2S_ServicePayload(i)
	}
	if len(src) > 0 {
		dst = make([]*C2S_ServicePayload, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*C2S_ServicePayload{}
		dst = nil
	}
	return dst
}

func (m C2S_ServicePayload) JsonString() string {
	ba, _ := json.Marshal(m)
	return "C2S_ServicePayload:" + string(ba)
}

func Request_S2C_ServicePayload(pid *actor.PID, send *C2S_ServicePayload) (*S2C_ServicePayload, error) {
	return Request_S2C_ServicePayload_T(pid, send, 10000*time.Millisecond)
}

func Request_S2C_ServicePayload_T(pid *actor.PID, send *C2S_ServicePayload, timeout time.Duration) (*S2C_ServicePayload, error) {
	if pid == nil {
		return nil, fmt.Errorf("pid is nil")
	}
	f := actor1.RootContext.RequestFuture(pid, send, timeout)
	iRecv, err := f.Result()
	if err != nil {
		return nil, err
	}
	recv, ok := iRecv.(*S2C_ServicePayload)
	if !ok {
		return nil, fmt.Errorf("recv %#v is not S2C_ServicePayload", recv)
	}
	return recv, nil
}

func (C2S_ServicePayload) CanIgnore() bool {
	return false
}

func New_C2S_ServicePayload() *C2S_ServicePayload {
	m := &C2S_ServicePayload{}
	return m
}

var g_C2S_ServicePayload_Pool = sync.Pool{}

func Get_C2S_ServicePayload() *C2S_ServicePayload {
	m, ok := g_C2S_ServicePayload_Pool.Get().(*C2S_ServicePayload)
	if !ok {
		m = New_C2S_ServicePayload()
	} else {
		if m == nil {
			m = New_C2S_ServicePayload()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_C2S_ServicePayload(i interface{}) {
	if m, ok := i.(*C2S_ServicePayload); ok && m != nil {
		g_C2S_ServicePayload_Pool.Put(i)
	}
}

// message [C2S_ServicePayload] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [S2C_ServicePayload] begin
func (m *S2C_ServicePayload) ResetEx() {

	if m.Err != nil {
		m.Err.ResetEx()
	} else {

		m.Err = Get_Error()

	}

	m.Payload = 0

}

func (m S2C_ServicePayload) Clone() *S2C_ServicePayload {
	n, ok := g_S2C_ServicePayload_Pool.Get().(*S2C_ServicePayload)
	if !ok || n == nil {
		n = &S2C_ServicePayload{}
	}

	if m.Err != nil {
		n.Err = m.Err.Clone()
	}

	n.Payload = m.Payload

	return n
}

func Clone_S2C_ServicePayload_Slice(dst []*S2C_ServicePayload, src []*S2C_ServicePayload) []*S2C_ServicePayload {
	for _, i := range dst {
		Put_S2C_ServicePayload(i)
	}
	if len(src) > 0 {
		dst = make([]*S2C_ServicePayload, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*S2C_ServicePayload{}
		dst = nil
	}
	return dst
}

func (m S2C_ServicePayload) JsonString() string {
	ba, _ := json.Marshal(m)
	return "S2C_ServicePayload:" + string(ba)
}

func (S2C_ServicePayload) CanIgnore() bool {
	return false
}

func New_S2C_ServicePayload() *S2C_ServicePayload {
	m := &S2C_ServicePayload{

		Err: New_Error(),
	}
	return m
}

var g_S2C_ServicePayload_Pool = sync.Pool{}

func Get_S2C_ServicePayload() *S2C_ServicePayload {
	m, ok := g_S2C_ServicePayload_Pool.Get().(*S2C_ServicePayload)
	if !ok {
		m = New_S2C_ServicePayload()
	} else {
		if m == nil {
			m = New_S2C_ServicePayload()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_S2C_ServicePayload(i interface{}) {
	if m, ok := i.(*S2C_ServicePayload); ok && m != nil {
		g_S2C_ServicePayload_Pool.Put(i)
	}
}

// message [S2C_ServicePayload] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [C2S_PutServicePayload] begin
func (m *C2S_PutServicePayload) ResetEx() {

	m.Name = ""

	m.ID = 0

	m.Payload = 0

}

func (m C2S_PutServicePayload) Clone() *C2S_PutServicePayload {
	n, ok := g_C2S_PutServicePayload_Pool.Get().(*C2S_PutServicePayload)
	if !ok || n == nil {
		n = &C2S_PutServicePayload{}
	}

	n.Name = m.Name

	n.ID = m.ID

	n.Payload = m.Payload

	return n
}

func Clone_C2S_PutServicePayload_Slice(dst []*C2S_PutServicePayload, src []*C2S_PutServicePayload) []*C2S_PutServicePayload {
	for _, i := range dst {
		Put_C2S_PutServicePayload(i)
	}
	if len(src) > 0 {
		dst = make([]*C2S_PutServicePayload, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*C2S_PutServicePayload{}
		dst = nil
	}
	return dst
}

func (m C2S_PutServicePayload) JsonString() string {
	ba, _ := json.Marshal(m)
	return "C2S_PutServicePayload:" + string(ba)
}

func Request_S2C_PutServicePayload(pid *actor.PID, send *C2S_PutServicePayload) (*S2C_PutServicePayload, error) {
	return Request_S2C_PutServicePayload_T(pid, send, 10000*time.Millisecond)
}

func Request_S2C_PutServicePayload_T(pid *actor.PID, send *C2S_PutServicePayload, timeout time.Duration) (*S2C_PutServicePayload, error) {
	if pid == nil {
		return nil, fmt.Errorf("pid is nil")
	}
	f := actor1.RootContext.RequestFuture(pid, send, timeout)
	iRecv, err := f.Result()
	if err != nil {
		return nil, err
	}
	recv, ok := iRecv.(*S2C_PutServicePayload)
	if !ok {
		return nil, fmt.Errorf("recv %#v is not S2C_PutServicePayload", recv)
	}
	return recv, nil
}

func (C2S_PutServicePayload) CanIgnore() bool {
	return false
}

func New_C2S_PutServicePayload() *C2S_PutServicePayload {
	m := &C2S_PutServicePayload{}
	return m
}

var g_C2S_PutServicePayload_Pool = sync.Pool{}

func Get_C2S_PutServicePayload() *C2S_PutServicePayload {
	m, ok := g_C2S_PutServicePayload_Pool.Get().(*C2S_PutServicePayload)
	if !ok {
		m = New_C2S_PutServicePayload()
	} else {
		if m == nil {
			m = New_C2S_PutServicePayload()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_C2S_PutServicePayload(i interface{}) {
	if m, ok := i.(*C2S_PutServicePayload); ok && m != nil {
		g_C2S_PutServicePayload_Pool.Put(i)
	}
}

// message [C2S_PutServicePayload] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [S2C_PutServicePayload] begin
func (m *S2C_PutServicePayload) ResetEx() {

	if m.Err != nil {
		m.Err.ResetEx()
	} else {

		m.Err = Get_Error()

	}

}

func (m S2C_PutServicePayload) Clone() *S2C_PutServicePayload {
	n, ok := g_S2C_PutServicePayload_Pool.Get().(*S2C_PutServicePayload)
	if !ok || n == nil {
		n = &S2C_PutServicePayload{}
	}

	if m.Err != nil {
		n.Err = m.Err.Clone()
	}

	return n
}

func Clone_S2C_PutServicePayload_Slice(dst []*S2C_PutServicePayload, src []*S2C_PutServicePayload) []*S2C_PutServicePayload {
	for _, i := range dst {
		Put_S2C_PutServicePayload(i)
	}
	if len(src) > 0 {
		dst = make([]*S2C_PutServicePayload, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*S2C_PutServicePayload{}
		dst = nil
	}
	return dst
}

func (m S2C_PutServicePayload) JsonString() string {
	ba, _ := json.Marshal(m)
	return "S2C_PutServicePayload:" + string(ba)
}

func (S2C_PutServicePayload) CanIgnore() bool {
	return false
}

func New_S2C_PutServicePayload() *S2C_PutServicePayload {
	m := &S2C_PutServicePayload{

		Err: New_Error(),
	}
	return m
}

var g_S2C_PutServicePayload_Pool = sync.Pool{}

func Get_S2C_PutServicePayload() *S2C_PutServicePayload {
	m, ok := g_S2C_PutServicePayload_Pool.Get().(*S2C_PutServicePayload)
	if !ok {
		m = New_S2C_PutServicePayload()
	} else {
		if m == nil {
			m = New_S2C_PutServicePayload()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_S2C_PutServicePayload(i interface{}) {
	if m, ok := i.(*S2C_PutServicePayload); ok && m != nil {
		g_S2C_PutServicePayload_Pool.Put(i)
	}
}

// message [S2C_PutServicePayload] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [C2S_ServiceGroupAllInfo] begin
func (m *C2S_ServiceGroupAllInfo) ResetEx() {

	m.Name = ""

}

func (m C2S_ServiceGroupAllInfo) Clone() *C2S_ServiceGroupAllInfo {
	n, ok := g_C2S_ServiceGroupAllInfo_Pool.Get().(*C2S_ServiceGroupAllInfo)
	if !ok || n == nil {
		n = &C2S_ServiceGroupAllInfo{}
	}

	n.Name = m.Name

	return n
}

func Clone_C2S_ServiceGroupAllInfo_Slice(dst []*C2S_ServiceGroupAllInfo, src []*C2S_ServiceGroupAllInfo) []*C2S_ServiceGroupAllInfo {
	for _, i := range dst {
		Put_C2S_ServiceGroupAllInfo(i)
	}
	if len(src) > 0 {
		dst = make([]*C2S_ServiceGroupAllInfo, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*C2S_ServiceGroupAllInfo{}
		dst = nil
	}
	return dst
}

func (m C2S_ServiceGroupAllInfo) JsonString() string {
	ba, _ := json.Marshal(m)
	return "C2S_ServiceGroupAllInfo:" + string(ba)
}

func Request_S2C_ServiceGroupAllInfo(pid *actor.PID, send *C2S_ServiceGroupAllInfo) (*S2C_ServiceGroupAllInfo, error) {
	return Request_S2C_ServiceGroupAllInfo_T(pid, send, 10000*time.Millisecond)
}

func Request_S2C_ServiceGroupAllInfo_T(pid *actor.PID, send *C2S_ServiceGroupAllInfo, timeout time.Duration) (*S2C_ServiceGroupAllInfo, error) {
	if pid == nil {
		return nil, fmt.Errorf("pid is nil")
	}
	f := actor1.RootContext.RequestFuture(pid, send, timeout)
	iRecv, err := f.Result()
	if err != nil {
		return nil, err
	}
	recv, ok := iRecv.(*S2C_ServiceGroupAllInfo)
	if !ok {
		return nil, fmt.Errorf("recv %#v is not S2C_ServiceGroupAllInfo", recv)
	}
	return recv, nil
}

func (C2S_ServiceGroupAllInfo) CanIgnore() bool {
	return false
}

func New_C2S_ServiceGroupAllInfo() *C2S_ServiceGroupAllInfo {
	m := &C2S_ServiceGroupAllInfo{}
	return m
}

var g_C2S_ServiceGroupAllInfo_Pool = sync.Pool{}

func Get_C2S_ServiceGroupAllInfo() *C2S_ServiceGroupAllInfo {
	m, ok := g_C2S_ServiceGroupAllInfo_Pool.Get().(*C2S_ServiceGroupAllInfo)
	if !ok {
		m = New_C2S_ServiceGroupAllInfo()
	} else {
		if m == nil {
			m = New_C2S_ServiceGroupAllInfo()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_C2S_ServiceGroupAllInfo(i interface{}) {
	if m, ok := i.(*C2S_ServiceGroupAllInfo); ok && m != nil {
		g_C2S_ServiceGroupAllInfo_Pool.Put(i)
	}
}

// message [C2S_ServiceGroupAllInfo] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [S2C_ServiceGroupAllInfo] begin
func (m *S2C_ServiceGroupAllInfo) ResetEx() {

	if m.Err != nil {
		m.Err.ResetEx()
	} else {

		m.Err = Get_Error()

	}

	for _, i := range m.Infos {

		Put_ServiceInfo(i)

	}

	//m.Infos = []*ServiceInfo{}
	m.Infos = nil

}

func (m S2C_ServiceGroupAllInfo) Clone() *S2C_ServiceGroupAllInfo {
	n, ok := g_S2C_ServiceGroupAllInfo_Pool.Get().(*S2C_ServiceGroupAllInfo)
	if !ok || n == nil {
		n = &S2C_ServiceGroupAllInfo{}
	}

	if m.Err != nil {
		n.Err = m.Err.Clone()
	}

	if len(m.Infos) > 0 {
		n.Infos = make([]*ServiceInfo, len(m.Infos))
		for i, e := range m.Infos {

			if e != nil {
				n.Infos[i] = e.Clone()
			}

		}
	} else {
		//n.Infos = []*ServiceInfo{}
		n.Infos = nil
	}

	return n
}

func Clone_S2C_ServiceGroupAllInfo_Slice(dst []*S2C_ServiceGroupAllInfo, src []*S2C_ServiceGroupAllInfo) []*S2C_ServiceGroupAllInfo {
	for _, i := range dst {
		Put_S2C_ServiceGroupAllInfo(i)
	}
	if len(src) > 0 {
		dst = make([]*S2C_ServiceGroupAllInfo, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*S2C_ServiceGroupAllInfo{}
		dst = nil
	}
	return dst
}

func (m S2C_ServiceGroupAllInfo) JsonString() string {
	ba, _ := json.Marshal(m)
	return "S2C_ServiceGroupAllInfo:" + string(ba)
}

func (S2C_ServiceGroupAllInfo) CanIgnore() bool {
	return false
}

func New_S2C_ServiceGroupAllInfo() *S2C_ServiceGroupAllInfo {
	m := &S2C_ServiceGroupAllInfo{

		Err: New_Error(),
	}
	return m
}

var g_S2C_ServiceGroupAllInfo_Pool = sync.Pool{}

func Get_S2C_ServiceGroupAllInfo() *S2C_ServiceGroupAllInfo {
	m, ok := g_S2C_ServiceGroupAllInfo_Pool.Get().(*S2C_ServiceGroupAllInfo)
	if !ok {
		m = New_S2C_ServiceGroupAllInfo()
	} else {
		if m == nil {
			m = New_S2C_ServiceGroupAllInfo()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_S2C_ServiceGroupAllInfo(i interface{}) {
	if m, ok := i.(*S2C_ServiceGroupAllInfo); ok && m != nil {
		g_S2C_ServiceGroupAllInfo_Pool.Put(i)
	}
}

// message [S2C_ServiceGroupAllInfo] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [C2S_RoundRobinPickServiceInstance] begin
func (m *C2S_RoundRobinPickServiceInstance) ResetEx() {

	m.Name = ""

}

func (m C2S_RoundRobinPickServiceInstance) Clone() *C2S_RoundRobinPickServiceInstance {
	n, ok := g_C2S_RoundRobinPickServiceInstance_Pool.Get().(*C2S_RoundRobinPickServiceInstance)
	if !ok || n == nil {
		n = &C2S_RoundRobinPickServiceInstance{}
	}

	n.Name = m.Name

	return n
}

func Clone_C2S_RoundRobinPickServiceInstance_Slice(dst []*C2S_RoundRobinPickServiceInstance, src []*C2S_RoundRobinPickServiceInstance) []*C2S_RoundRobinPickServiceInstance {
	for _, i := range dst {
		Put_C2S_RoundRobinPickServiceInstance(i)
	}
	if len(src) > 0 {
		dst = make([]*C2S_RoundRobinPickServiceInstance, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*C2S_RoundRobinPickServiceInstance{}
		dst = nil
	}
	return dst
}

func (m C2S_RoundRobinPickServiceInstance) JsonString() string {
	ba, _ := json.Marshal(m)
	return "C2S_RoundRobinPickServiceInstance:" + string(ba)
}

func Request_S2C_RoundRobinPickServiceInstance(pid *actor.PID, send *C2S_RoundRobinPickServiceInstance) (*S2C_RoundRobinPickServiceInstance, error) {
	return Request_S2C_RoundRobinPickServiceInstance_T(pid, send, 10000*time.Millisecond)
}

func Request_S2C_RoundRobinPickServiceInstance_T(pid *actor.PID, send *C2S_RoundRobinPickServiceInstance, timeout time.Duration) (*S2C_RoundRobinPickServiceInstance, error) {
	if pid == nil {
		return nil, fmt.Errorf("pid is nil")
	}
	f := actor1.RootContext.RequestFuture(pid, send, timeout)
	iRecv, err := f.Result()
	if err != nil {
		return nil, err
	}
	recv, ok := iRecv.(*S2C_RoundRobinPickServiceInstance)
	if !ok {
		return nil, fmt.Errorf("recv %#v is not S2C_RoundRobinPickServiceInstance", recv)
	}
	return recv, nil
}

func (C2S_RoundRobinPickServiceInstance) CanIgnore() bool {
	return false
}

func New_C2S_RoundRobinPickServiceInstance() *C2S_RoundRobinPickServiceInstance {
	m := &C2S_RoundRobinPickServiceInstance{}
	return m
}

var g_C2S_RoundRobinPickServiceInstance_Pool = sync.Pool{}

func Get_C2S_RoundRobinPickServiceInstance() *C2S_RoundRobinPickServiceInstance {
	m, ok := g_C2S_RoundRobinPickServiceInstance_Pool.Get().(*C2S_RoundRobinPickServiceInstance)
	if !ok {
		m = New_C2S_RoundRobinPickServiceInstance()
	} else {
		if m == nil {
			m = New_C2S_RoundRobinPickServiceInstance()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_C2S_RoundRobinPickServiceInstance(i interface{}) {
	if m, ok := i.(*C2S_RoundRobinPickServiceInstance); ok && m != nil {
		g_C2S_RoundRobinPickServiceInstance_Pool.Put(i)
	}
}

// message [C2S_RoundRobinPickServiceInstance] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// message [S2C_RoundRobinPickServiceInstance] begin
func (m *S2C_RoundRobinPickServiceInstance) ResetEx() {

	if m.Err != nil {
		m.Err.ResetEx()
	} else {

		m.Err = Get_Error()

	}

	if m.Info != nil {
		m.Info.ResetEx()
	} else {

		m.Info = Get_ServiceInfo()

	}

}

func (m S2C_RoundRobinPickServiceInstance) Clone() *S2C_RoundRobinPickServiceInstance {
	n, ok := g_S2C_RoundRobinPickServiceInstance_Pool.Get().(*S2C_RoundRobinPickServiceInstance)
	if !ok || n == nil {
		n = &S2C_RoundRobinPickServiceInstance{}
	}

	if m.Err != nil {
		n.Err = m.Err.Clone()
	}

	if m.Info != nil {
		n.Info = m.Info.Clone()
	}

	return n
}

func Clone_S2C_RoundRobinPickServiceInstance_Slice(dst []*S2C_RoundRobinPickServiceInstance, src []*S2C_RoundRobinPickServiceInstance) []*S2C_RoundRobinPickServiceInstance {
	for _, i := range dst {
		Put_S2C_RoundRobinPickServiceInstance(i)
	}
	if len(src) > 0 {
		dst = make([]*S2C_RoundRobinPickServiceInstance, len(src))
		for i, e := range src {
			if e != nil {
				dst[i] = e.Clone()
			}
		}
	} else {
		//dst = []*S2C_RoundRobinPickServiceInstance{}
		dst = nil
	}
	return dst
}

func (m S2C_RoundRobinPickServiceInstance) JsonString() string {
	ba, _ := json.Marshal(m)
	return "S2C_RoundRobinPickServiceInstance:" + string(ba)
}

func (S2C_RoundRobinPickServiceInstance) CanIgnore() bool {
	return false
}

func New_S2C_RoundRobinPickServiceInstance() *S2C_RoundRobinPickServiceInstance {
	m := &S2C_RoundRobinPickServiceInstance{

		Err: New_Error(),

		Info: New_ServiceInfo(),
	}
	return m
}

var g_S2C_RoundRobinPickServiceInstance_Pool = sync.Pool{}

func Get_S2C_RoundRobinPickServiceInstance() *S2C_RoundRobinPickServiceInstance {
	m, ok := g_S2C_RoundRobinPickServiceInstance_Pool.Get().(*S2C_RoundRobinPickServiceInstance)
	if !ok {
		m = New_S2C_RoundRobinPickServiceInstance()
	} else {
		if m == nil {
			m = New_S2C_RoundRobinPickServiceInstance()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_S2C_RoundRobinPickServiceInstance(i interface{}) {
	if m, ok := i.(*S2C_RoundRobinPickServiceInstance); ok && m != nil {
		g_S2C_RoundRobinPickServiceInstance_Pool.Put(i)
	}
}

// message [S2C_RoundRobinPickServiceInstance] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////