// Code generated by protoc-gen-client-model-go. DO NOT EDIT IT!!!
// source: user.proto

package model

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	math "math"
	msg "msg"
	sync "sync"
)

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// model [Test] begin

func New_Test() *Test {
	m := &Test{}
	return m
}

func (m Test) JsonString() string {
	bs, _ := json.Marshal(m)
	return fmt.Sprintf("{\"Test\":%s}", string(bs))
}

func (m *Test) ResetEx() {

	m.I32 = 0

	m.U32 = 0

	m.Str = ""

}

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

	n.I32 = m.I32

	n.U32 = m.U32

	n.Str = m.Str

	return n
}

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

func (m *Test) FromMsg(n *msg.Test) *Test {
	m.ResetEx()

	if n == nil {
		return m
	}

	m.I32 = n.i

	m.U32 = n.U32

	m.Str = n.Str

	return m
}

type Int64ToTestMap map[int64]*Test

func ToInt64ToTestMap(m map[int64]*Test) *Int64ToTestMap {
	if m == nil {
		return nil
	}
	return (*Int64ToTestMap)(&m)
}

func NewInt64ToTestMap() (m *Int64ToTestMap) {
	m = &Int64ToTestMap{}
	return
}

func (m *Int64ToTestMap) Get(key int64) (value *Test, ok bool) {
	value, ok = (*m)[key]
	return
}

func (m *Int64ToTestMap) Set(key int64, value *Test) {
	(*m)[key] = value
}

func (m *Int64ToTestMap) Add(key int64) (value *Test) {
	value = Get_Test()
	(*m)[key] = value
	return
}

func (m *Int64ToTestMap) Remove(key int64) (removed bool) {
	if _, ok := (*m)[key]; ok {
		delete(*m, key)
		return true
	}
	return false
}

func (m *Int64ToTestMap) RemoveOne(fn func(key int64, value *Test) (removed bool)) {
	for key, value := range *m {
		if fn(key, value) {
			delete(*m, key)
			break
		}
	}
}

func (m *Int64ToTestMap) RemoveSome(fn func(key int64, value *Test) (removed bool)) {
	left := map[int64]*Test{}
	for key, value := range *m {
		if !fn(key, value) {
			left[key] = value
		}
	}
	*m = left
}

func (m *Int64ToTestMap) Each(f func(key int64, value *Test) (continued bool)) {
	for key, value := range *m {
		if !f(key, value) {
			break
		}
	}
}

func (m Int64ToTestMap) Size() int {
	return len(m)
}

func (m Int64ToTestMap) Clone() (n *Int64ToTestMap) {
	if m.Size() == 0 {
		return nil
	}
	n = ToInt64ToTestMap(make(map[int64]*Test, m.Size()))
	for k, v := range m {
		if v != nil {
			(*n)[k] = v.Clone()
		} else {
			(*n)[k] = nil
		}
	}
	return n
}

func (m *Int64ToTestMap) Clear() {
	*m = *NewInt64ToTestMap()
}

func (m *Int64ToTestMap) FromMsg(n map[int64]*msg.Test) *Int64ToTestMap {
	m.Clear()
	if len(n) == 0 {
		return nil
	}
	for k, v := range n {
		if v != nil {
			m.Set(k, Get_Test().FromMsg(v))
		} else {
			m.Set(k, Get_Test())
		}
	}
	return m
}

type Int32ToTestMap map[int32]*Test

func ToInt32ToTestMap(m map[int32]*Test) *Int32ToTestMap {
	if m == nil {
		return nil
	}
	return (*Int32ToTestMap)(&m)
}

func NewInt32ToTestMap() (m *Int32ToTestMap) {
	m = &Int32ToTestMap{}
	return
}

func (m *Int32ToTestMap) Get(key int32) (value *Test, ok bool) {
	value, ok = (*m)[key]
	return
}

func (m *Int32ToTestMap) Set(key int32, value *Test) {
	(*m)[key] = value
}

func (m *Int32ToTestMap) Add(key int32) (value *Test) {
	value = Get_Test()
	(*m)[key] = value
	return
}

func (m *Int32ToTestMap) Remove(key int32) (removed bool) {
	if _, ok := (*m)[key]; ok {
		delete(*m, key)
		return true
	}
	return false
}

func (m *Int32ToTestMap) RemoveOne(fn func(key int32, value *Test) (removed bool)) {
	for key, value := range *m {
		if fn(key, value) {
			delete(*m, key)
			break
		}
	}
}

func (m *Int32ToTestMap) RemoveSome(fn func(key int32, value *Test) (removed bool)) {
	left := map[int32]*Test{}
	for key, value := range *m {
		if !fn(key, value) {
			left[key] = value
		}
	}
	*m = left
}

func (m *Int32ToTestMap) Each(f func(key int32, value *Test) (continued bool)) {
	for key, value := range *m {
		if !f(key, value) {
			break
		}
	}
}

func (m Int32ToTestMap) Size() int {
	return len(m)
}

func (m Int32ToTestMap) Clone() (n *Int32ToTestMap) {
	if m.Size() == 0 {
		return nil
	}
	n = ToInt32ToTestMap(make(map[int32]*Test, m.Size()))
	for k, v := range m {
		if v != nil {
			(*n)[k] = v.Clone()
		} else {
			(*n)[k] = nil
		}
	}
	return n
}

func (m *Int32ToTestMap) Clear() {
	*m = *NewInt32ToTestMap()
}

func (m *Int32ToTestMap) FromMsg(n map[int32]*msg.Test) *Int32ToTestMap {
	m.Clear()
	if len(n) == 0 {
		return nil
	}
	for k, v := range n {
		if v != nil {
			m.Set(k, Get_Test().FromMsg(v))
		} else {
			m.Set(k, Get_Test())
		}
	}
	return m
}

type TestSlice []*Test

func NewTestSlice() *TestSlice {
	return &TestSlice{}
}

func ToTestSlice(s []*Test) *TestSlice {
	return (*TestSlice)(&s)
}

func (s *TestSlice) Add() *Test {
	return s.AddOne(Get_Test())
}

func (s *TestSlice) AddOne(newOne *Test) *Test {
	*s = append(*s, newOne)
	return newOne
}

func (s *TestSlice) RemoveOne(fn func(index int, element *Test) (removed bool)) {
	for i, e := range *s {
		if fn(i, e) {
			*s = append((*s)[:i], (*s)[i+1:]...)
			break
		}
	}
}

func (s *TestSlice) RemoveSome(fn func(index int, element *Test) (removed bool)) {
	var left []*Test
	for i, e := range *s {
		if !fn(i, e) {
			left = append(left, e)
		}
	}
	*s = left
}

func (s TestSlice) Each(fn func(index int, element *Test) (continued bool)) {
	for i, e := range s {
		if !fn(i, e) {
			break
		}
	}
}

func (s TestSlice) Size() int {
	return len(s)
}

func (s TestSlice) Clone() (n *TestSlice) {
	if s.Size() == 0 {
		return nil
	}
	n = ToTestSlice(make([]*Test, s.Size()))
	for i, e := range s {
		if e != nil {
			(*n)[i] = e.Clone()
		} else {
			(*n)[i] = nil
		}
	}
	return n
}

func (s *TestSlice) Clear() {
	*s = *NewTestSlice()
}

func (s TestSlice) ToMsg(n []*msg.Test) []*msg.Test {
	if s.Size() == 0 {
		return nil
	}
	n = make([]*msg.Test, s.Size())
	for i, e := range s {
		if e != nil {
			n[i] = e.ToMsg(nil)
		} else {
			n[i] = msg.Get_Test()
		}
	}
	return n
}

var g_Test_Pool = sync.Pool{}

func Get_Test() *Test {
	m, ok := g_Test_Pool.Get().(*Test)
	if !ok {
		m = New_Test()
	} else {
		if m == nil {
			m = New_Test()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_Test(i interface{}) {
	if m, ok := i.(*Test); ok && m != nil {
		g_Test_Pool.Put(i)
	}
}

// model [Test] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// model [User] begin

func New_User() *User {
	m := &User{

		Test: Get_Test(),
	}
	return m
}

func (m User) JsonString() string {
	bs, _ := json.Marshal(m)
	return fmt.Sprintf("{\"User\":%s}", string(bs))
}

func (m *User) ResetEx() {

	m.ID = 0

	m.AccountID = 0

	m.ServerID = 0

	m.Name = ""

	m.Sex = 0

	m.CreateTime = 0

	//m.Arr = []int32{}
	m.Arr = nil

	//m.StrArr = []string{}
	m.StrArr = nil

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

	for _, i := range m.Tests {
		Put_Test(i)
	}

	//m.Tests = []*Test{}
	m.Tests = nil

	//m.IMap = map[int32]int32{}
	m.IMap = nil

	for _, i := range m.TestMap {
		Put_Test(i)
	}

	//m.TestMap = map[int32]*Test{}
	m.TestMap = nil

}

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

	n.ID = m.ID

	n.AccountID = m.AccountID

	n.ServerID = m.ServerID

	n.Name = m.Name

	n.Sex = m.Sex

	n.CreateTime = m.CreateTime

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

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

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

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

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

		}
	} else {
		//n.Tests = []*Test{}
		n.Tests = nil
	}

	if len(m.IMap) > 0 {
		n.IMap = make(map[int32]int32, len(m.IMap))
		for i, e := range m.IMap {

			n.IMap[i] = e

		}
	} else {
		//n.IMap = map[int32]int32{}
		n.IMap = nil
	}

	if len(m.TestMap) > 0 {
		n.TestMap = make(map[int32]*Test, len(m.TestMap))
		for i, e := range m.TestMap {

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

		}
	} else {
		//n.TestMap = map[int32]*Test{}
		n.TestMap = nil
	}

	return n
}

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

func (m *User) FromMsg(n *msg.User) *User {
	m.ResetEx()

	if n == nil {
		return m
	}

	m.ID = n.ID

	m.AccountID = n.AccountID

	m.ServerID = n.ServerID

	m.Name = n.Name

	m.Sex = n.Sex

	m.CreateTime = n.CreateTime

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

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

	if n.Test != nil {
		m.Test = m.Test.FromMsg(n.Test)
	}

	if len(m.Tests) > 0 {

		m.Tests = make([]*Test, len(n.Tests))
		for i, e := range n.Tests {
			if e != nil {
				m.Tests[i] = Get_Test().FromMsg(e)
			} else {
				m.Tests[i] = Get_Test()
			}
		}

	} else {
		//m.Tests = []*Test{}
		m.Tests = nil
	}

	if len(m.IMap) > 0 {

		m.IMap = make(map[int32]int32, len(n.IMap))
		for i, e := range n.IMap {
			m.IMap[i] = e
		}

	} else {
		//m.IMap = map[int32]int32{}
		m.IMap = nil
	}

	if len(m.TestMap) > 0 {

		m.TestMap = make(map[int32]*Test, len(n.TestMap))
		for i, e := range n.TestMap {
			if e != nil {
				m.TestMap[i] = Get_Test().FromMsg(e)
			} else {
				m.TestMap[i] = Get_Test()
			}
		}

	} else {
		//m.TestMap = map[int32]*Test{}
		m.TestMap = nil
	}

	return m
}

var g_User_Pool = sync.Pool{}

func Get_User() *User {
	m, ok := g_User_Pool.Get().(*User)
	if !ok {
		m = New_User()
	} else {
		if m == nil {
			m = New_User()
		} else {
			m.ResetEx()
		}
	}
	return m
}

func Put_User(i interface{}) {
	if m, ok := i.(*User); ok && m != nil {
		g_User_Pool.Put(i)
	}
}

// model [User] end
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////