login.enum.go

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

/*
It has these top-level messages:
	S2C_Close
	C2S_Register
	S2C_Register
	C2S_Login
	S2C_Login
*/

package msg

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// enum [E_Test] begin

type E_Test int32

const (
	E_Test_ E_Test = 0

	E_Test_OK E_Test = 1
)

var E_Test_name = map[int32]string{
	0: "E_Test_",
	1: "E_Test_OK",
}

var E_Test_value = map[string]int32{
	"E_Test_":   0,
	"E_Test_OK": 1,
}

var E_Test_Slice = []int32{
	0,
	1,
}

func (x E_Test) String() string {
	if name, ok := E_Test_name[int32(x)]; ok {
		return name
	}
	return ""
}

func E_Test_Len() int {
	return len(E_Test_Slice)
}

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

func Check_E_Test(value E_Test) bool {
	return Check_E_Test_I(int32(value))
}

func Each_E_Test(f func(E_Test) bool) {
	for _, value := range E_Test_Slice {
		if !f(E_Test(value)) {
			break
		}
	}
}

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

// enum [E_Test] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// enum [S2C_Register_E_Error] begin

/// 错误码
type S2C_Register_E_Error int32

const (
	Error_ S2C_Register_E_Error = 0
	/// 成功
	OK S2C_Register_E_Error = 1
	/// 无效帐号名
	InvalidAccountName S2C_Register_E_Error = 2
	/// 无效密码
	InvalidPassword S2C_Register_E_Error = 3
	/// 已存在
	Exist S2C_Register_E_Error = 4
)

var S2C_Register_E_Error_name = map[int32]string{
	0: "Error_",
	1: "OK",
	2: "InvalidAccountName",
	3: "InvalidPassword",
	4: "Exist",
}

var S2C_Register_E_Error_value = map[string]int32{
	"Error_":             0,
	"OK":                 1,
	"InvalidAccountName": 2,
	"InvalidPassword":    3,
	"Exist":              4,
}

var S2C_Register_E_Error_Slice = []int32{
	0,
	1,
	2,
	3,
	4,
}

func (x S2C_Register_E_Error) String() string {
	if name, ok := S2C_Register_E_Error_name[int32(x)]; ok {
		return name
	}
	return ""
}

func S2C_Register_E_Error_Len() int {
	return len(S2C_Register_E_Error_Slice)
}

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

func Check_S2C_Register_E_Error(value S2C_Register_E_Error) bool {
	return Check_S2C_Register_E_Error_I(int32(value))
}

func Each_S2C_Register_E_Error(f func(S2C_Register_E_Error) bool) {
	for _, value := range S2C_Register_E_Error_Slice {
		if !f(S2C_Register_E_Error(value)) {
			break
		}
	}
}

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

// enum [S2C_Register_E_Error] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// enum [S2C_Register_E_State] begin

/// 注册返回的帐号状态
type S2C_Register_E_State int32

const (
	State_ S2C_Register_E_State = 0
	/// 游客
	Visitor S2C_Register_E_State = 1
	/// 注册
	Register S2C_Register_E_State = 2
	/// 绑定
	Bind S2C_Register_E_State = 3
)

var S2C_Register_E_State_name = map[int32]string{
	0: "State_",
	1: "Visitor",
	2: "Register",
	3: "Bind",
}

var S2C_Register_E_State_value = map[string]int32{
	"State_":   0,
	"Visitor":  1,
	"Register": 2,
	"Bind":     3,
}

var S2C_Register_E_State_Slice = []int32{
	0,
	1,
	2,
	3,
}

func (x S2C_Register_E_State) String() string {
	if name, ok := S2C_Register_E_State_name[int32(x)]; ok {
		return name
	}
	return ""
}

func S2C_Register_E_State_Len() int {
	return len(S2C_Register_E_State_Slice)
}

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

func Check_S2C_Register_E_State(value S2C_Register_E_State) bool {
	return Check_S2C_Register_E_State_I(int32(value))
}

func Each_S2C_Register_E_State(f func(S2C_Register_E_State) bool) {
	for _, value := range S2C_Register_E_State_Slice {
		if !f(S2C_Register_E_State(value)) {
			break
		}
	}
}

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

// enum [S2C_Register_E_State] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// enum [S2C_Login_E_Error] begin

/// 登录错误码枚举
type S2C_Login_E_Error int32

const (
	S2C_Login_E_Error_ S2C_Login_E_Error = 0
	/// 成功
	S2C_Login_E_Error_OK S2C_Login_E_Error = 1
	/// 非法帐号
	S2C_Login_E_Error_InvalidAccount S2C_Login_E_Error = 2
	/// 帐号不存在
	S2C_Login_E_Error_NotExist S2C_Login_E_Error = 3
	/// 非法密码
	S2C_Login_E_Error_InvalidPassword S2C_Login_E_Error = 4
	/// 已封号
	S2C_Login_E_Error_Ban S2C_Login_E_Error = 5
)

var S2C_Login_E_Error_name = map[int32]string{
	0: "S2C_Login_E_Error_",
	1: "S2C_Login_E_Error_OK",
	2: "S2C_Login_E_Error_InvalidAccount",
	3: "S2C_Login_E_Error_NotExist",
	4: "S2C_Login_E_Error_InvalidPassword",
	5: "S2C_Login_E_Error_Ban",
}

var S2C_Login_E_Error_value = map[string]int32{
	"S2C_Login_E_Error_":                0,
	"S2C_Login_E_Error_OK":              1,
	"S2C_Login_E_Error_InvalidAccount":  2,
	"S2C_Login_E_Error_NotExist":        3,
	"S2C_Login_E_Error_InvalidPassword": 4,
	"S2C_Login_E_Error_Ban":             5,
}

var S2C_Login_E_Error_Slice = []int32{
	0,
	1,
	2,
	3,
	4,
	5,
}

func (x S2C_Login_E_Error) String() string {
	if name, ok := S2C_Login_E_Error_name[int32(x)]; ok {
		return name
	}
	return ""
}

func S2C_Login_E_Error_Len() int {
	return len(S2C_Login_E_Error_Slice)
}

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

func Check_S2C_Login_E_Error(value S2C_Login_E_Error) bool {
	return Check_S2C_Login_E_Error_I(int32(value))
}

func Each_S2C_Login_E_Error(f func(S2C_Login_E_Error) bool) {
	for _, value := range S2C_Login_E_Error_Slice {
		if !f(S2C_Login_E_Error(value)) {
			break
		}
	}
}

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

// enum [S2C_Login_E_Error] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////