net4g

type ByteSerializer struct {
	*EmptySerializer
}

type Closer interface {
	Close()
}

type Dispatcher struct {
	Name string
	// contains filtered or unexported fields
}

type EmptySerializer struct {
	SerializerTypeIdMap   map[reflect.Type]interface{}
	SerializerIdTypeMap   map[interface{}]reflect.Type
	DeserializerTypeIdMap map[reflect.Type]interface{}
	DeserializerIdTypeMap map[interface{}]reflect.Type
	// contains filtered or unexported fields
}

type Intercepter interface {
	Intercept(data []byte) []byte
}

type JsonSerializer struct {
	*EmptySerializer
}

type NetAddr struct {
	Key  string
	Addr string
}

type NetAgent interface {
	RawPack() *RawPack
	Header() interface{}
	Msg() interface{}
	RemoteAddr() net.Addr
	Session() NetSession
	Key(key ...string) string
	Write(v interface{}, h ...interface{}) error
	Close()
	IsClosed() bool
}

type NetConn interface {
	RemoteAddr() net.Addr
	Read() (p []byte, err error)
	Write(p []byte) error
	Session() NetSession
	Close()
	IsClosed() bool
	NotWrittenData() [][]byte
	PopCount() (read int64, write int64)
	PopDataUsage() (read int64, write int64)
}

type NetHub interface {
	Add(key string, conn NetConn)
	Key(conn NetConn, key string)
	Get(key string) NetConn
	Remove(conn NetConn)
	Slice() []NetConn
	Count() int
	Heartbeat(conn NetConn)
	Kick(key string)
	SetSerializer(serializer Serializer)
	Broadcast(v interface{}, filter func(session NetSession) bool, h ...interface{}) error
	BroadcastAll(v interface{}, h ...interface{}) error
	BroadcastOthers(mySession NetSession, v interface{}, h ...interface{}) error
	BroadcastOne(v interface{}, errFunc func(error), h ...interface{}) error
	Send(key string, v interface{}) error
	MultiSend(keys []string, v interface{}) error
	SetGroup(session NetSession, group string)
	Group(group string, v interface{}, h ...interface{}) error
	GroupOne(group string, v interface{}, errFunc func(error), h ...interface{}) error
	RangeConn(f func(NetConn))
	RangeSession(f func(session NetSession))
	Statistics()
	PackCount() (totalRead int64, totalWrite int64, popRead int64, popWrite int64)
	DataUsage() (totalRead int64, totalWrite int64, popRead int64, popWrite int64)
	Closed() bool
	Destroy()
}

type NetReader interface {
	Read(after func(data []byte) bool)
}

type NetSession interface {
	Set(key string, value interface{})
	Get(key string, defaultValue ...interface{}) interface{}
	GetString(key string, defaultValue ...string) string
	GetInt(key string, defaultValue ...int) int
	GetInt64(key string, defaultValue ...int64) int64
	GetBool(key string, defaultValue ...bool) bool
	Has(key string) bool
	Remove(key string)
	SetLogin()
	IsLogin() bool
}

type NetTimer interface {
	Start(d time.Duration)
	Stop() bool
}

type NetTimerEvent struct {
	// contains filtered or unexported fields
}

type NetWriter interface {
	Write(p []byte)
}

type ProtobufSerializer struct {
	*EmptySerializer
}

type RawPack struct {
	Id     interface{}
	Type   reflect.Type
	Header []byte
	Data   []byte
}

type ReadMode string

type Serializer interface {
	SetIdInitValue(id int)
	RegisterId(v interface{}, one_id ...interface{}) (id interface{}, err error)
	RegisterSerializeId(v interface{}, one_id ...interface{}) (id interface{}, err error)
	RegisterDeserializeId(v interface{}, one_id ...interface{}) (id interface{}, err error)
	Serialize(v, h interface{}) (data []byte, err error)
	DeserializeId(raw []byte) (id interface{}, t reflect.Type, data []byte, err error)
	DeserializeData(data []byte, t reflect.Type) (h, v interface{}, err error)
	RangeId(f func(id interface{}, t reflect.Type))
}

type StringSerializer struct {
	*EmptySerializer
}

type TCPClient struct {
	AutoReconnect bool
	// contains filtered or unexported fields
}

type TCPServer struct {
	Name string
	Addr string

	Serializer Serializer
	Dispatcher *Dispatcher
	// contains filtered or unexported fields
}