// Autogenerated by Thrift Compiler (0.9.2)
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING

package messageservice

import (
	"bytes"
	"fmt"
	"git.apache.org/thrift.git/lib/go/thrift"
)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = bytes.Equal

type MessageService interface {
	// Parameters:
	//  - UserId
	Online(userId *UserId) (err error)
	// Parameters:
	//  - UserId
	Offline(userId *UserId) (err error)
	// Parameters:
	//  - UserId
	KeepAlive(userId *UserId) (err error)
	// Parameters:
	//  - UserId
	//  - Cmd
	//  - Message
	SendMessage(userId *UserId, cmd int16, message string) (err error)
	// Parameters:
	//  - UserIdCollection
	//  - Cmd
	//  - Message
	SendMessageToUserIdCollection(userIdCollection UserIdCollection, cmd int16, message string) (err error)
	// Parameters:
	//  - UserIdCollection
	GetUserOnlineStatus(userIdCollection UserIdCollection) (r []bool, err error)
	// Parameters:
	//  - UserIdCollection
	//  - Cmd
	//  - Message
	SendMessageWithOneOfflineMessage(userIdCollection UserIdCollection, cmd int16, message string) (err error)
	// Parameters:
	//  - Nsp
	//  - Room
	//  - Cmd
	//  - Message
	SendMessageToRoom(nsp string, room string, cmd int16, message string) (err error)
}

type MessageServiceClient struct {
	Transport       thrift.TTransport
	ProtocolFactory thrift.TProtocolFactory
	InputProtocol   thrift.TProtocol
	OutputProtocol  thrift.TProtocol
	SeqId           int32
}

func NewMessageServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *MessageServiceClient {
	return &MessageServiceClient{Transport: t,
		ProtocolFactory: f,
		InputProtocol:   f.GetProtocol(t),
		OutputProtocol:  f.GetProtocol(t),
		SeqId:           0,
	}
}

func NewMessageServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *MessageServiceClient {
	return &MessageServiceClient{Transport: t,
		ProtocolFactory: nil,
		InputProtocol:   iprot,
		OutputProtocol:  oprot,
		SeqId:           0,
	}
}

// Parameters:
//  - UserId
func (p *MessageServiceClient) Online(userId *UserId) (err error) {
	if err = p.sendOnline(userId); err != nil {
		return
	}
	return p.recvOnline()
}

func (p *MessageServiceClient) sendOnline(userId *UserId) (err error) {
	oprot := p.OutputProtocol
	if oprot == nil {
		oprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.OutputProtocol = oprot
	}
	p.SeqId++
	if err = oprot.WriteMessageBegin("online", thrift.CALL, p.SeqId); err != nil {
		return
	}
	args := OnlineArgs{
		UserId: userId,
	}
	if err = args.Write(oprot); err != nil {
		return
	}
	if err = oprot.WriteMessageEnd(); err != nil {
		return
	}
	return oprot.Flush()
}

func (p *MessageServiceClient) recvOnline() (err error) {
	iprot := p.InputProtocol
	if iprot == nil {
		iprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.InputProtocol = iprot
	}
	_, mTypeId, seqId, err := iprot.ReadMessageBegin()
	if err != nil {
		return
	}
	if mTypeId == thrift.EXCEPTION {
		error0 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
		var error1 error
		error1, err = error0.Read(iprot)
		if err != nil {
			return
		}
		if err = iprot.ReadMessageEnd(); err != nil {
			return
		}
		err = error1
		return
	}
	if p.SeqId != seqId {
		err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "online failed: out of sequence response")
		return
	}
	result := OnlineResult{}
	if err = result.Read(iprot); err != nil {
		return
	}
	if err = iprot.ReadMessageEnd(); err != nil {
		return
	}
	if result.ErrorA1 != nil {
		err = result.ErrorA1
		return
	}
	return
}

// Parameters:
//  - UserId
func (p *MessageServiceClient) Offline(userId *UserId) (err error) {
	if err = p.sendOffline(userId); err != nil {
		return
	}
	return p.recvOffline()
}

func (p *MessageServiceClient) sendOffline(userId *UserId) (err error) {
	oprot := p.OutputProtocol
	if oprot == nil {
		oprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.OutputProtocol = oprot
	}
	p.SeqId++
	if err = oprot.WriteMessageBegin("offline", thrift.CALL, p.SeqId); err != nil {
		return
	}
	args := OfflineArgs{
		UserId: userId,
	}
	if err = args.Write(oprot); err != nil {
		return
	}
	if err = oprot.WriteMessageEnd(); err != nil {
		return
	}
	return oprot.Flush()
}

func (p *MessageServiceClient) recvOffline() (err error) {
	iprot := p.InputProtocol
	if iprot == nil {
		iprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.InputProtocol = iprot
	}
	_, mTypeId, seqId, err := iprot.ReadMessageBegin()
	if err != nil {
		return
	}
	if mTypeId == thrift.EXCEPTION {
		error2 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
		var error3 error
		error3, err = error2.Read(iprot)
		if err != nil {
			return
		}
		if err = iprot.ReadMessageEnd(); err != nil {
			return
		}
		err = error3
		return
	}
	if p.SeqId != seqId {
		err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "offline failed: out of sequence response")
		return
	}
	result := OfflineResult{}
	if err = result.Read(iprot); err != nil {
		return
	}
	if err = iprot.ReadMessageEnd(); err != nil {
		return
	}
	if result.ErrorA1 != nil {
		err = result.ErrorA1
		return
	}
	return
}

// Parameters:
//  - UserId
func (p *MessageServiceClient) KeepAlive(userId *UserId) (err error) {
	if err = p.sendKeepAlive(userId); err != nil {
		return
	}
	return p.recvKeepAlive()
}

func (p *MessageServiceClient) sendKeepAlive(userId *UserId) (err error) {
	oprot := p.OutputProtocol
	if oprot == nil {
		oprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.OutputProtocol = oprot
	}
	p.SeqId++
	if err = oprot.WriteMessageBegin("keepAlive", thrift.CALL, p.SeqId); err != nil {
		return
	}
	args := KeepAliveArgs{
		UserId: userId,
	}
	if err = args.Write(oprot); err != nil {
		return
	}
	if err = oprot.WriteMessageEnd(); err != nil {
		return
	}
	return oprot.Flush()
}

func (p *MessageServiceClient) recvKeepAlive() (err error) {
	iprot := p.InputProtocol
	if iprot == nil {
		iprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.InputProtocol = iprot
	}
	_, mTypeId, seqId, err := iprot.ReadMessageBegin()
	if err != nil {
		return
	}
	if mTypeId == thrift.EXCEPTION {
		error4 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
		var error5 error
		error5, err = error4.Read(iprot)
		if err != nil {
			return
		}
		if err = iprot.ReadMessageEnd(); err != nil {
			return
		}
		err = error5
		return
	}
	if p.SeqId != seqId {
		err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "keepAlive failed: out of sequence response")
		return
	}
	result := KeepAliveResult{}
	if err = result.Read(iprot); err != nil {
		return
	}
	if err = iprot.ReadMessageEnd(); err != nil {
		return
	}
	if result.ErrorA1 != nil {
		err = result.ErrorA1
		return
	}
	return
}

// Parameters:
//  - UserId
//  - Cmd
//  - Message
func (p *MessageServiceClient) SendMessage(userId *UserId, cmd int16, message string) (err error) {
	if err = p.sendSendMessage(userId, cmd, message); err != nil {
		return
	}
	return p.recvSendMessage()
}

func (p *MessageServiceClient) sendSendMessage(userId *UserId, cmd int16, message string) (err error) {
	oprot := p.OutputProtocol
	if oprot == nil {
		oprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.OutputProtocol = oprot
	}
	p.SeqId++
	if err = oprot.WriteMessageBegin("sendMessage", thrift.CALL, p.SeqId); err != nil {
		return
	}
	args := SendMessageArgs{
		UserId:  userId,
		Cmd:     cmd,
		Message: message,
	}
	if err = args.Write(oprot); err != nil {
		return
	}
	if err = oprot.WriteMessageEnd(); err != nil {
		return
	}
	return oprot.Flush()
}

func (p *MessageServiceClient) recvSendMessage() (err error) {
	iprot := p.InputProtocol
	if iprot == nil {
		iprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.InputProtocol = iprot
	}
	_, mTypeId, seqId, err := iprot.ReadMessageBegin()
	if err != nil {
		return
	}
	if mTypeId == thrift.EXCEPTION {
		error6 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
		var error7 error
		error7, err = error6.Read(iprot)
		if err != nil {
			return
		}
		if err = iprot.ReadMessageEnd(); err != nil {
			return
		}
		err = error7
		return
	}
	if p.SeqId != seqId {
		err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "sendMessage failed: out of sequence response")
		return
	}
	result := SendMessageResult{}
	if err = result.Read(iprot); err != nil {
		return
	}
	if err = iprot.ReadMessageEnd(); err != nil {
		return
	}
	if result.ErrorA1 != nil {
		err = result.ErrorA1
		return
	}
	return
}

// Parameters:
//  - UserIdCollection
//  - Cmd
//  - Message
func (p *MessageServiceClient) SendMessageToUserIdCollection(userIdCollection UserIdCollection, cmd int16, message string) (err error) {
	if err = p.sendSendMessageToUserIdCollection(userIdCollection, cmd, message); err != nil {
		return
	}
	return p.recvSendMessageToUserIdCollection()
}

func (p *MessageServiceClient) sendSendMessageToUserIdCollection(userIdCollection UserIdCollection, cmd int16, message string) (err error) {
	oprot := p.OutputProtocol
	if oprot == nil {
		oprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.OutputProtocol = oprot
	}
	p.SeqId++
	if err = oprot.WriteMessageBegin("sendMessageToUserIdCollection", thrift.CALL, p.SeqId); err != nil {
		return
	}
	args := SendMessageToUserIdCollectionArgs{
		UserIdCollection: userIdCollection,
		Cmd:              cmd,
		Message:          message,
	}
	if err = args.Write(oprot); err != nil {
		return
	}
	if err = oprot.WriteMessageEnd(); err != nil {
		return
	}
	return oprot.Flush()
}

func (p *MessageServiceClient) recvSendMessageToUserIdCollection() (err error) {
	iprot := p.InputProtocol
	if iprot == nil {
		iprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.InputProtocol = iprot
	}
	_, mTypeId, seqId, err := iprot.ReadMessageBegin()
	if err != nil {
		return
	}
	if mTypeId == thrift.EXCEPTION {
		error8 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
		var error9 error
		error9, err = error8.Read(iprot)
		if err != nil {
			return
		}
		if err = iprot.ReadMessageEnd(); err != nil {
			return
		}
		err = error9
		return
	}
	if p.SeqId != seqId {
		err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "sendMessageToUserIdCollection failed: out of sequence response")
		return
	}
	result := SendMessageToUserIdCollectionResult{}
	if err = result.Read(iprot); err != nil {
		return
	}
	if err = iprot.ReadMessageEnd(); err != nil {
		return
	}
	if result.ErrorA1 != nil {
		err = result.ErrorA1
		return
	}
	return
}

// Parameters:
//  - UserIdCollection
func (p *MessageServiceClient) GetUserOnlineStatus(userIdCollection UserIdCollection) (r []bool, err error) {
	if err = p.sendGetUserOnlineStatus(userIdCollection); err != nil {
		return
	}
	return p.recvGetUserOnlineStatus()
}

func (p *MessageServiceClient) sendGetUserOnlineStatus(userIdCollection UserIdCollection) (err error) {
	oprot := p.OutputProtocol
	if oprot == nil {
		oprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.OutputProtocol = oprot
	}
	p.SeqId++
	if err = oprot.WriteMessageBegin("getUserOnlineStatus", thrift.CALL, p.SeqId); err != nil {
		return
	}
	args := GetUserOnlineStatusArgs{
		UserIdCollection: userIdCollection,
	}
	if err = args.Write(oprot); err != nil {
		return
	}
	if err = oprot.WriteMessageEnd(); err != nil {
		return
	}
	return oprot.Flush()
}

func (p *MessageServiceClient) recvGetUserOnlineStatus() (value []bool, err error) {
	iprot := p.InputProtocol
	if iprot == nil {
		iprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.InputProtocol = iprot
	}
	_, mTypeId, seqId, err := iprot.ReadMessageBegin()
	if err != nil {
		return
	}
	if mTypeId == thrift.EXCEPTION {
		error10 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
		var error11 error
		error11, err = error10.Read(iprot)
		if err != nil {
			return
		}
		if err = iprot.ReadMessageEnd(); err != nil {
			return
		}
		err = error11
		return
	}
	if p.SeqId != seqId {
		err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "getUserOnlineStatus failed: out of sequence response")
		return
	}
	result := GetUserOnlineStatusResult{}
	if err = result.Read(iprot); err != nil {
		return
	}
	if err = iprot.ReadMessageEnd(); err != nil {
		return
	}
	if result.ErrorA1 != nil {
		err = result.ErrorA1
		return
	}
	value = result.GetSuccess()
	return
}

// Parameters:
//  - UserIdCollection
//  - Cmd
//  - Message
func (p *MessageServiceClient) SendMessageWithOneOfflineMessage(userIdCollection UserIdCollection, cmd int16, message string) (err error) {
	if err = p.sendSendMessageWithOneOfflineMessage(userIdCollection, cmd, message); err != nil {
		return
	}
	return p.recvSendMessageWithOneOfflineMessage()
}

func (p *MessageServiceClient) sendSendMessageWithOneOfflineMessage(userIdCollection UserIdCollection, cmd int16, message string) (err error) {
	oprot := p.OutputProtocol
	if oprot == nil {
		oprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.OutputProtocol = oprot
	}
	p.SeqId++
	if err = oprot.WriteMessageBegin("sendMessageWithOneOfflineMessage", thrift.CALL, p.SeqId); err != nil {
		return
	}
	args := SendMessageWithOneOfflineMessageArgs{
		UserIdCollection: userIdCollection,
		Cmd:              cmd,
		Message:          message,
	}
	if err = args.Write(oprot); err != nil {
		return
	}
	if err = oprot.WriteMessageEnd(); err != nil {
		return
	}
	return oprot.Flush()
}

func (p *MessageServiceClient) recvSendMessageWithOneOfflineMessage() (err error) {
	iprot := p.InputProtocol
	if iprot == nil {
		iprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.InputProtocol = iprot
	}
	_, mTypeId, seqId, err := iprot.ReadMessageBegin()
	if err != nil {
		return
	}
	if mTypeId == thrift.EXCEPTION {
		error12 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
		var error13 error
		error13, err = error12.Read(iprot)
		if err != nil {
			return
		}
		if err = iprot.ReadMessageEnd(); err != nil {
			return
		}
		err = error13
		return
	}
	if p.SeqId != seqId {
		err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "sendMessageWithOneOfflineMessage failed: out of sequence response")
		return
	}
	result := SendMessageWithOneOfflineMessageResult{}
	if err = result.Read(iprot); err != nil {
		return
	}
	if err = iprot.ReadMessageEnd(); err != nil {
		return
	}
	if result.ErrorA1 != nil {
		err = result.ErrorA1
		return
	}
	return
}

// Parameters:
//  - Nsp
//  - Room
//  - Cmd
//  - Message
func (p *MessageServiceClient) SendMessageToRoom(nsp string, room string, cmd int16, message string) (err error) {
	if err = p.sendSendMessageToRoom(nsp, room, cmd, message); err != nil {
		return
	}
	return p.recvSendMessageToRoom()
}

func (p *MessageServiceClient) sendSendMessageToRoom(nsp string, room string, cmd int16, message string) (err error) {
	oprot := p.OutputProtocol
	if oprot == nil {
		oprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.OutputProtocol = oprot
	}
	p.SeqId++
	if err = oprot.WriteMessageBegin("sendMessageToRoom", thrift.CALL, p.SeqId); err != nil {
		return
	}
	args := SendMessageToRoomArgs{
		Nsp:     nsp,
		Room:    room,
		Cmd:     cmd,
		Message: message,
	}
	if err = args.Write(oprot); err != nil {
		return
	}
	if err = oprot.WriteMessageEnd(); err != nil {
		return
	}
	return oprot.Flush()
}

func (p *MessageServiceClient) recvSendMessageToRoom() (err error) {
	iprot := p.InputProtocol
	if iprot == nil {
		iprot = p.ProtocolFactory.GetProtocol(p.Transport)
		p.InputProtocol = iprot
	}
	_, mTypeId, seqId, err := iprot.ReadMessageBegin()
	if err != nil {
		return
	}
	if mTypeId == thrift.EXCEPTION {
		error14 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
		var error15 error
		error15, err = error14.Read(iprot)
		if err != nil {
			return
		}
		if err = iprot.ReadMessageEnd(); err != nil {
			return
		}
		err = error15
		return
	}
	if p.SeqId != seqId {
		err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "sendMessageToRoom failed: out of sequence response")
		return
	}
	result := SendMessageToRoomResult{}
	if err = result.Read(iprot); err != nil {
		return
	}
	if err = iprot.ReadMessageEnd(); err != nil {
		return
	}
	if result.ErrorA1 != nil {
		err = result.ErrorA1
		return
	}
	return
}

type MessageServiceProcessor struct {
	processorMap map[string]thrift.TProcessorFunction
	handler      MessageService
}

func (p *MessageServiceProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) {
	p.processorMap[key] = processor
}

func (p *MessageServiceProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) {
	processor, ok = p.processorMap[key]
	return processor, ok
}

func (p *MessageServiceProcessor) ProcessorMap() map[string]thrift.TProcessorFunction {
	return p.processorMap
}

func NewMessageServiceProcessor(handler MessageService) *MessageServiceProcessor {

	self16 := &MessageServiceProcessor{handler: handler, processorMap: make(map[string]thrift.TProcessorFunction)}
	self16.processorMap["online"] = &messageServiceProcessorOnline{handler: handler}
	self16.processorMap["offline"] = &messageServiceProcessorOffline{handler: handler}
	self16.processorMap["keepAlive"] = &messageServiceProcessorKeepAlive{handler: handler}
	self16.processorMap["sendMessage"] = &messageServiceProcessorSendMessage{handler: handler}
	self16.processorMap["sendMessageToUserIdCollection"] = &messageServiceProcessorSendMessageToUserIdCollection{handler: handler}
	self16.processorMap["getUserOnlineStatus"] = &messageServiceProcessorGetUserOnlineStatus{handler: handler}
	self16.processorMap["sendMessageWithOneOfflineMessage"] = &messageServiceProcessorSendMessageWithOneOfflineMessage{handler: handler}
	self16.processorMap["sendMessageToRoom"] = &messageServiceProcessorSendMessageToRoom{handler: handler}
	return self16
}

func (p *MessageServiceProcessor) Process(iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	name, _, seqId, err := iprot.ReadMessageBegin()
	if err != nil {
		return false, err
	}
	if processor, ok := p.GetProcessorFunction(name); ok {
		return processor.Process(seqId, iprot, oprot)
	}
	iprot.Skip(thrift.STRUCT)
	iprot.ReadMessageEnd()
	x17 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function "+name)
	oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId)
	x17.Write(oprot)
	oprot.WriteMessageEnd()
	oprot.Flush()
	return false, x17

}

type messageServiceProcessorOnline struct {
	handler MessageService
}

func (p *messageServiceProcessorOnline) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := OnlineArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("online", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return false, err
	}

	iprot.ReadMessageEnd()
	result := OnlineResult{}
	var err2 error
	if err2 = p.handler.Online(args.UserId); err2 != nil {
		switch v := err2.(type) {
		case *Error:
			result.ErrorA1 = v
		default:
			x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing online: "+err2.Error())
			oprot.WriteMessageBegin("online", thrift.EXCEPTION, seqId)
			x.Write(oprot)
			oprot.WriteMessageEnd()
			oprot.Flush()
			return true, err2
		}
	}
	if err2 = oprot.WriteMessageBegin("online", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type messageServiceProcessorOffline struct {
	handler MessageService
}

func (p *messageServiceProcessorOffline) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := OfflineArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("offline", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return false, err
	}

	iprot.ReadMessageEnd()
	result := OfflineResult{}
	var err2 error
	if err2 = p.handler.Offline(args.UserId); err2 != nil {
		switch v := err2.(type) {
		case *Error:
			result.ErrorA1 = v
		default:
			x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing offline: "+err2.Error())
			oprot.WriteMessageBegin("offline", thrift.EXCEPTION, seqId)
			x.Write(oprot)
			oprot.WriteMessageEnd()
			oprot.Flush()
			return true, err2
		}
	}
	if err2 = oprot.WriteMessageBegin("offline", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type messageServiceProcessorKeepAlive struct {
	handler MessageService
}

func (p *messageServiceProcessorKeepAlive) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := KeepAliveArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("keepAlive", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return false, err
	}

	iprot.ReadMessageEnd()
	result := KeepAliveResult{}
	var err2 error
	if err2 = p.handler.KeepAlive(args.UserId); err2 != nil {
		switch v := err2.(type) {
		case *Error:
			result.ErrorA1 = v
		default:
			x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing keepAlive: "+err2.Error())
			oprot.WriteMessageBegin("keepAlive", thrift.EXCEPTION, seqId)
			x.Write(oprot)
			oprot.WriteMessageEnd()
			oprot.Flush()
			return true, err2
		}
	}
	if err2 = oprot.WriteMessageBegin("keepAlive", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type messageServiceProcessorSendMessage struct {
	handler MessageService
}

func (p *messageServiceProcessorSendMessage) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := SendMessageArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("sendMessage", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return false, err
	}

	iprot.ReadMessageEnd()
	result := SendMessageResult{}
	var err2 error
	if err2 = p.handler.SendMessage(args.UserId, args.Cmd, args.Message); err2 != nil {
		switch v := err2.(type) {
		case *Error:
			result.ErrorA1 = v
		default:
			x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing sendMessage: "+err2.Error())
			oprot.WriteMessageBegin("sendMessage", thrift.EXCEPTION, seqId)
			x.Write(oprot)
			oprot.WriteMessageEnd()
			oprot.Flush()
			return true, err2
		}
	}
	if err2 = oprot.WriteMessageBegin("sendMessage", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type messageServiceProcessorSendMessageToUserIdCollection struct {
	handler MessageService
}

func (p *messageServiceProcessorSendMessageToUserIdCollection) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := SendMessageToUserIdCollectionArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("sendMessageToUserIdCollection", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return false, err
	}

	iprot.ReadMessageEnd()
	result := SendMessageToUserIdCollectionResult{}
	var err2 error
	if err2 = p.handler.SendMessageToUserIdCollection(args.UserIdCollection, args.Cmd, args.Message); err2 != nil {
		switch v := err2.(type) {
		case *Error:
			result.ErrorA1 = v
		default:
			x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing sendMessageToUserIdCollection: "+err2.Error())
			oprot.WriteMessageBegin("sendMessageToUserIdCollection", thrift.EXCEPTION, seqId)
			x.Write(oprot)
			oprot.WriteMessageEnd()
			oprot.Flush()
			return true, err2
		}
	}
	if err2 = oprot.WriteMessageBegin("sendMessageToUserIdCollection", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type messageServiceProcessorGetUserOnlineStatus struct {
	handler MessageService
}

func (p *messageServiceProcessorGetUserOnlineStatus) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := GetUserOnlineStatusArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("getUserOnlineStatus", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return false, err
	}

	iprot.ReadMessageEnd()
	result := GetUserOnlineStatusResult{}
	var retval []bool
	var err2 error
	if retval, err2 = p.handler.GetUserOnlineStatus(args.UserIdCollection); err2 != nil {
		switch v := err2.(type) {
		case *Error:
			result.ErrorA1 = v
		default:
			x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getUserOnlineStatus: "+err2.Error())
			oprot.WriteMessageBegin("getUserOnlineStatus", thrift.EXCEPTION, seqId)
			x.Write(oprot)
			oprot.WriteMessageEnd()
			oprot.Flush()
			return true, err2
		}
	} else {
		result.Success = retval
	}
	if err2 = oprot.WriteMessageBegin("getUserOnlineStatus", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type messageServiceProcessorSendMessageWithOneOfflineMessage struct {
	handler MessageService
}

func (p *messageServiceProcessorSendMessageWithOneOfflineMessage) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := SendMessageWithOneOfflineMessageArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("sendMessageWithOneOfflineMessage", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return false, err
	}

	iprot.ReadMessageEnd()
	result := SendMessageWithOneOfflineMessageResult{}
	var err2 error
	if err2 = p.handler.SendMessageWithOneOfflineMessage(args.UserIdCollection, args.Cmd, args.Message); err2 != nil {
		switch v := err2.(type) {
		case *Error:
			result.ErrorA1 = v
		default:
			x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing sendMessageWithOneOfflineMessage: "+err2.Error())
			oprot.WriteMessageBegin("sendMessageWithOneOfflineMessage", thrift.EXCEPTION, seqId)
			x.Write(oprot)
			oprot.WriteMessageEnd()
			oprot.Flush()
			return true, err2
		}
	}
	if err2 = oprot.WriteMessageBegin("sendMessageWithOneOfflineMessage", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

type messageServiceProcessorSendMessageToRoom struct {
	handler MessageService
}

func (p *messageServiceProcessorSendMessageToRoom) Process(seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
	args := SendMessageToRoomArgs{}
	if err = args.Read(iprot); err != nil {
		iprot.ReadMessageEnd()
		x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
		oprot.WriteMessageBegin("sendMessageToRoom", thrift.EXCEPTION, seqId)
		x.Write(oprot)
		oprot.WriteMessageEnd()
		oprot.Flush()
		return false, err
	}

	iprot.ReadMessageEnd()
	result := SendMessageToRoomResult{}
	var err2 error
	if err2 = p.handler.SendMessageToRoom(args.Nsp, args.Room, args.Cmd, args.Message); err2 != nil {
		switch v := err2.(type) {
		case *Error:
			result.ErrorA1 = v
		default:
			x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing sendMessageToRoom: "+err2.Error())
			oprot.WriteMessageBegin("sendMessageToRoom", thrift.EXCEPTION, seqId)
			x.Write(oprot)
			oprot.WriteMessageEnd()
			oprot.Flush()
			return true, err2
		}
	}
	if err2 = oprot.WriteMessageBegin("sendMessageToRoom", thrift.REPLY, seqId); err2 != nil {
		err = err2
	}
	if err2 = result.Write(oprot); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
		err = err2
	}
	if err2 = oprot.Flush(); err == nil && err2 != nil {
		err = err2
	}
	if err != nil {
		return
	}
	return true, err
}

// HELPER FUNCTIONS AND STRUCTURES

type OnlineArgs struct {
	UserId *UserId `thrift:"userId,1" json:"userId"`
}

func NewOnlineArgs() *OnlineArgs {
	return &OnlineArgs{}
}

var OnlineArgs_UserId_DEFAULT *UserId

func (p *OnlineArgs) GetUserId() *UserId {
	if !p.IsSetUserId() {
		return OnlineArgs_UserId_DEFAULT
	}
	return p.UserId
}
func (p *OnlineArgs) IsSetUserId() bool {
	return p.UserId != nil
}

func (p *OnlineArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *OnlineArgs) ReadField1(iprot thrift.TProtocol) error {
	p.UserId = &UserId{}
	if err := p.UserId.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.UserId, err)
	}
	return nil
}

func (p *OnlineArgs) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("online_args"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *OnlineArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("userId", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:userId: %s", p, err)
	}
	if err := p.UserId.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.UserId, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:userId: %s", p, err)
	}
	return err
}

func (p *OnlineArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("OnlineArgs(%+v)", *p)
}

type OnlineResult struct {
	ErrorA1 *Error `thrift:"error,1" json:"error"`
}

func NewOnlineResult() *OnlineResult {
	return &OnlineResult{}
}

var OnlineResult_ErrorA1_DEFAULT *Error

func (p *OnlineResult) GetErrorA1() *Error {
	if !p.IsSetErrorA1() {
		return OnlineResult_ErrorA1_DEFAULT
	}
	return p.ErrorA1
}
func (p *OnlineResult) IsSetErrorA1() bool {
	return p.ErrorA1 != nil
}

func (p *OnlineResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *OnlineResult) ReadField1(iprot thrift.TProtocol) error {
	p.ErrorA1 = &Error{}
	if err := p.ErrorA1.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.ErrorA1, err)
	}
	return nil
}

func (p *OnlineResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("online_result"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *OnlineResult) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetErrorA1() {
		if err := oprot.WriteFieldBegin("error", thrift.STRUCT, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:error: %s", p, err)
		}
		if err := p.ErrorA1.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.ErrorA1, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:error: %s", p, err)
		}
	}
	return err
}

func (p *OnlineResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("OnlineResult(%+v)", *p)
}

type OfflineArgs struct {
	UserId *UserId `thrift:"userId,1" json:"userId"`
}

func NewOfflineArgs() *OfflineArgs {
	return &OfflineArgs{}
}

var OfflineArgs_UserId_DEFAULT *UserId

func (p *OfflineArgs) GetUserId() *UserId {
	if !p.IsSetUserId() {
		return OfflineArgs_UserId_DEFAULT
	}
	return p.UserId
}
func (p *OfflineArgs) IsSetUserId() bool {
	return p.UserId != nil
}

func (p *OfflineArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *OfflineArgs) ReadField1(iprot thrift.TProtocol) error {
	p.UserId = &UserId{}
	if err := p.UserId.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.UserId, err)
	}
	return nil
}

func (p *OfflineArgs) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("offline_args"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *OfflineArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("userId", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:userId: %s", p, err)
	}
	if err := p.UserId.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.UserId, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:userId: %s", p, err)
	}
	return err
}

func (p *OfflineArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("OfflineArgs(%+v)", *p)
}

type OfflineResult struct {
	ErrorA1 *Error `thrift:"error,1" json:"error"`
}

func NewOfflineResult() *OfflineResult {
	return &OfflineResult{}
}

var OfflineResult_ErrorA1_DEFAULT *Error

func (p *OfflineResult) GetErrorA1() *Error {
	if !p.IsSetErrorA1() {
		return OfflineResult_ErrorA1_DEFAULT
	}
	return p.ErrorA1
}
func (p *OfflineResult) IsSetErrorA1() bool {
	return p.ErrorA1 != nil
}

func (p *OfflineResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *OfflineResult) ReadField1(iprot thrift.TProtocol) error {
	p.ErrorA1 = &Error{}
	if err := p.ErrorA1.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.ErrorA1, err)
	}
	return nil
}

func (p *OfflineResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("offline_result"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *OfflineResult) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetErrorA1() {
		if err := oprot.WriteFieldBegin("error", thrift.STRUCT, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:error: %s", p, err)
		}
		if err := p.ErrorA1.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.ErrorA1, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:error: %s", p, err)
		}
	}
	return err
}

func (p *OfflineResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("OfflineResult(%+v)", *p)
}

type KeepAliveArgs struct {
	UserId *UserId `thrift:"userId,1" json:"userId"`
}

func NewKeepAliveArgs() *KeepAliveArgs {
	return &KeepAliveArgs{}
}

var KeepAliveArgs_UserId_DEFAULT *UserId

func (p *KeepAliveArgs) GetUserId() *UserId {
	if !p.IsSetUserId() {
		return KeepAliveArgs_UserId_DEFAULT
	}
	return p.UserId
}
func (p *KeepAliveArgs) IsSetUserId() bool {
	return p.UserId != nil
}

func (p *KeepAliveArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *KeepAliveArgs) ReadField1(iprot thrift.TProtocol) error {
	p.UserId = &UserId{}
	if err := p.UserId.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.UserId, err)
	}
	return nil
}

func (p *KeepAliveArgs) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("keepAlive_args"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *KeepAliveArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("userId", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:userId: %s", p, err)
	}
	if err := p.UserId.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.UserId, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:userId: %s", p, err)
	}
	return err
}

func (p *KeepAliveArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("KeepAliveArgs(%+v)", *p)
}

type KeepAliveResult struct {
	ErrorA1 *Error `thrift:"error,1" json:"error"`
}

func NewKeepAliveResult() *KeepAliveResult {
	return &KeepAliveResult{}
}

var KeepAliveResult_ErrorA1_DEFAULT *Error

func (p *KeepAliveResult) GetErrorA1() *Error {
	if !p.IsSetErrorA1() {
		return KeepAliveResult_ErrorA1_DEFAULT
	}
	return p.ErrorA1
}
func (p *KeepAliveResult) IsSetErrorA1() bool {
	return p.ErrorA1 != nil
}

func (p *KeepAliveResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *KeepAliveResult) ReadField1(iprot thrift.TProtocol) error {
	p.ErrorA1 = &Error{}
	if err := p.ErrorA1.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.ErrorA1, err)
	}
	return nil
}

func (p *KeepAliveResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("keepAlive_result"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *KeepAliveResult) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetErrorA1() {
		if err := oprot.WriteFieldBegin("error", thrift.STRUCT, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:error: %s", p, err)
		}
		if err := p.ErrorA1.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.ErrorA1, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:error: %s", p, err)
		}
	}
	return err
}

func (p *KeepAliveResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("KeepAliveResult(%+v)", *p)
}

type SendMessageArgs struct {
	UserId  *UserId `thrift:"userId,1" json:"userId"`
	Cmd     int16   `thrift:"cmd,2" json:"cmd"`
	Message string  `thrift:"message,3" json:"message"`
}

func NewSendMessageArgs() *SendMessageArgs {
	return &SendMessageArgs{}
}

var SendMessageArgs_UserId_DEFAULT *UserId

func (p *SendMessageArgs) GetUserId() *UserId {
	if !p.IsSetUserId() {
		return SendMessageArgs_UserId_DEFAULT
	}
	return p.UserId
}

func (p *SendMessageArgs) GetCmd() int16 {
	return p.Cmd
}

func (p *SendMessageArgs) GetMessage() string {
	return p.Message
}
func (p *SendMessageArgs) IsSetUserId() bool {
	return p.UserId != nil
}

func (p *SendMessageArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *SendMessageArgs) ReadField1(iprot thrift.TProtocol) error {
	p.UserId = &UserId{}
	if err := p.UserId.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.UserId, err)
	}
	return nil
}

func (p *SendMessageArgs) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI16(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Cmd = v
	}
	return nil
}

func (p *SendMessageArgs) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *SendMessageArgs) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("sendMessage_args"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *SendMessageArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("userId", thrift.STRUCT, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:userId: %s", p, err)
	}
	if err := p.UserId.Write(oprot); err != nil {
		return fmt.Errorf("%T error writing struct: %s", p.UserId, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:userId: %s", p, err)
	}
	return err
}

func (p *SendMessageArgs) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("cmd", thrift.I16, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:cmd: %s", p, err)
	}
	if err := oprot.WriteI16(int16(p.Cmd)); err != nil {
		return fmt.Errorf("%T.cmd (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:cmd: %s", p, err)
	}
	return err
}

func (p *SendMessageArgs) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:message: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return fmt.Errorf("%T.message (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:message: %s", p, err)
	}
	return err
}

func (p *SendMessageArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("SendMessageArgs(%+v)", *p)
}

type SendMessageResult struct {
	ErrorA1 *Error `thrift:"error,1" json:"error"`
}

func NewSendMessageResult() *SendMessageResult {
	return &SendMessageResult{}
}

var SendMessageResult_ErrorA1_DEFAULT *Error

func (p *SendMessageResult) GetErrorA1() *Error {
	if !p.IsSetErrorA1() {
		return SendMessageResult_ErrorA1_DEFAULT
	}
	return p.ErrorA1
}
func (p *SendMessageResult) IsSetErrorA1() bool {
	return p.ErrorA1 != nil
}

func (p *SendMessageResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *SendMessageResult) ReadField1(iprot thrift.TProtocol) error {
	p.ErrorA1 = &Error{}
	if err := p.ErrorA1.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.ErrorA1, err)
	}
	return nil
}

func (p *SendMessageResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("sendMessage_result"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *SendMessageResult) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetErrorA1() {
		if err := oprot.WriteFieldBegin("error", thrift.STRUCT, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:error: %s", p, err)
		}
		if err := p.ErrorA1.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.ErrorA1, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:error: %s", p, err)
		}
	}
	return err
}

func (p *SendMessageResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("SendMessageResult(%+v)", *p)
}

type SendMessageToUserIdCollectionArgs struct {
	UserIdCollection UserIdCollection `thrift:"userIdCollection,1" json:"userIdCollection"`
	Cmd              int16            `thrift:"cmd,2" json:"cmd"`
	Message          string           `thrift:"message,3" json:"message"`
}

func NewSendMessageToUserIdCollectionArgs() *SendMessageToUserIdCollectionArgs {
	return &SendMessageToUserIdCollectionArgs{}
}

func (p *SendMessageToUserIdCollectionArgs) GetUserIdCollection() UserIdCollection {
	return p.UserIdCollection
}

func (p *SendMessageToUserIdCollectionArgs) GetCmd() int16 {
	return p.Cmd
}

func (p *SendMessageToUserIdCollectionArgs) GetMessage() string {
	return p.Message
}
func (p *SendMessageToUserIdCollectionArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *SendMessageToUserIdCollectionArgs) ReadField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make(UserIdCollection, 0, size)
	p.UserIdCollection = tSlice
	for i := 0; i < size; i++ {
		_elem18 := &UserId{}
		if err := _elem18.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem18, err)
		}
		p.UserIdCollection = append(p.UserIdCollection, _elem18)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *SendMessageToUserIdCollectionArgs) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI16(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Cmd = v
	}
	return nil
}

func (p *SendMessageToUserIdCollectionArgs) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *SendMessageToUserIdCollectionArgs) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("sendMessageToUserIdCollection_args"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *SendMessageToUserIdCollectionArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("userIdCollection", thrift.LIST, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:userIdCollection: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.UserIdCollection)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.UserIdCollection {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:userIdCollection: %s", p, err)
	}
	return err
}

func (p *SendMessageToUserIdCollectionArgs) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("cmd", thrift.I16, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:cmd: %s", p, err)
	}
	if err := oprot.WriteI16(int16(p.Cmd)); err != nil {
		return fmt.Errorf("%T.cmd (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:cmd: %s", p, err)
	}
	return err
}

func (p *SendMessageToUserIdCollectionArgs) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:message: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return fmt.Errorf("%T.message (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:message: %s", p, err)
	}
	return err
}

func (p *SendMessageToUserIdCollectionArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("SendMessageToUserIdCollectionArgs(%+v)", *p)
}

type SendMessageToUserIdCollectionResult struct {
	ErrorA1 *Error `thrift:"error,1" json:"error"`
}

func NewSendMessageToUserIdCollectionResult() *SendMessageToUserIdCollectionResult {
	return &SendMessageToUserIdCollectionResult{}
}

var SendMessageToUserIdCollectionResult_ErrorA1_DEFAULT *Error

func (p *SendMessageToUserIdCollectionResult) GetErrorA1() *Error {
	if !p.IsSetErrorA1() {
		return SendMessageToUserIdCollectionResult_ErrorA1_DEFAULT
	}
	return p.ErrorA1
}
func (p *SendMessageToUserIdCollectionResult) IsSetErrorA1() bool {
	return p.ErrorA1 != nil
}

func (p *SendMessageToUserIdCollectionResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *SendMessageToUserIdCollectionResult) ReadField1(iprot thrift.TProtocol) error {
	p.ErrorA1 = &Error{}
	if err := p.ErrorA1.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.ErrorA1, err)
	}
	return nil
}

func (p *SendMessageToUserIdCollectionResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("sendMessageToUserIdCollection_result"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *SendMessageToUserIdCollectionResult) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetErrorA1() {
		if err := oprot.WriteFieldBegin("error", thrift.STRUCT, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:error: %s", p, err)
		}
		if err := p.ErrorA1.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.ErrorA1, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:error: %s", p, err)
		}
	}
	return err
}

func (p *SendMessageToUserIdCollectionResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("SendMessageToUserIdCollectionResult(%+v)", *p)
}

type GetUserOnlineStatusArgs struct {
	UserIdCollection UserIdCollection `thrift:"userIdCollection,1" json:"userIdCollection"`
}

func NewGetUserOnlineStatusArgs() *GetUserOnlineStatusArgs {
	return &GetUserOnlineStatusArgs{}
}

func (p *GetUserOnlineStatusArgs) GetUserIdCollection() UserIdCollection {
	return p.UserIdCollection
}
func (p *GetUserOnlineStatusArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *GetUserOnlineStatusArgs) ReadField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make(UserIdCollection, 0, size)
	p.UserIdCollection = tSlice
	for i := 0; i < size; i++ {
		_elem19 := &UserId{}
		if err := _elem19.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem19, err)
		}
		p.UserIdCollection = append(p.UserIdCollection, _elem19)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *GetUserOnlineStatusArgs) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("getUserOnlineStatus_args"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *GetUserOnlineStatusArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("userIdCollection", thrift.LIST, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:userIdCollection: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.UserIdCollection)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.UserIdCollection {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:userIdCollection: %s", p, err)
	}
	return err
}

func (p *GetUserOnlineStatusArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("GetUserOnlineStatusArgs(%+v)", *p)
}

type GetUserOnlineStatusResult struct {
	Success []bool `thrift:"success,0" json:"success"`
	ErrorA1 *Error `thrift:"error,1" json:"error"`
}

func NewGetUserOnlineStatusResult() *GetUserOnlineStatusResult {
	return &GetUserOnlineStatusResult{}
}

var GetUserOnlineStatusResult_Success_DEFAULT []bool

func (p *GetUserOnlineStatusResult) GetSuccess() []bool {
	return p.Success
}

var GetUserOnlineStatusResult_ErrorA1_DEFAULT *Error

func (p *GetUserOnlineStatusResult) GetErrorA1() *Error {
	if !p.IsSetErrorA1() {
		return GetUserOnlineStatusResult_ErrorA1_DEFAULT
	}
	return p.ErrorA1
}
func (p *GetUserOnlineStatusResult) IsSetSuccess() bool {
	return p.Success != nil
}

func (p *GetUserOnlineStatusResult) IsSetErrorA1() bool {
	return p.ErrorA1 != nil
}

func (p *GetUserOnlineStatusResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 0:
			if err := p.ReadField0(iprot); err != nil {
				return err
			}
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *GetUserOnlineStatusResult) ReadField0(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make([]bool, 0, size)
	p.Success = tSlice
	for i := 0; i < size; i++ {
		var _elem20 bool
		if v, err := iprot.ReadBool(); err != nil {
			return fmt.Errorf("error reading field 0: %s", err)
		} else {
			_elem20 = v
		}
		p.Success = append(p.Success, _elem20)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *GetUserOnlineStatusResult) ReadField1(iprot thrift.TProtocol) error {
	p.ErrorA1 = &Error{}
	if err := p.ErrorA1.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.ErrorA1, err)
	}
	return nil
}

func (p *GetUserOnlineStatusResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("getUserOnlineStatus_result"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField0(oprot); err != nil {
		return err
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *GetUserOnlineStatusResult) writeField0(oprot thrift.TProtocol) (err error) {
	if p.IsSetSuccess() {
		if err := oprot.WriteFieldBegin("success", thrift.LIST, 0); err != nil {
			return fmt.Errorf("%T write field begin error 0:success: %s", p, err)
		}
		if err := oprot.WriteListBegin(thrift.BOOL, len(p.Success)); err != nil {
			return fmt.Errorf("error writing list begin: %s", err)
		}
		for _, v := range p.Success {
			if err := oprot.WriteBool(bool(v)); err != nil {
				return fmt.Errorf("%T. (0) field write error: %s", p, err)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return fmt.Errorf("error writing list end: %s", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 0:success: %s", p, err)
		}
	}
	return err
}

func (p *GetUserOnlineStatusResult) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetErrorA1() {
		if err := oprot.WriteFieldBegin("error", thrift.STRUCT, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:error: %s", p, err)
		}
		if err := p.ErrorA1.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.ErrorA1, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:error: %s", p, err)
		}
	}
	return err
}

func (p *GetUserOnlineStatusResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("GetUserOnlineStatusResult(%+v)", *p)
}

type SendMessageWithOneOfflineMessageArgs struct {
	UserIdCollection UserIdCollection `thrift:"userIdCollection,1" json:"userIdCollection"`
	Cmd              int16            `thrift:"cmd,2" json:"cmd"`
	Message          string           `thrift:"message,3" json:"message"`
}

func NewSendMessageWithOneOfflineMessageArgs() *SendMessageWithOneOfflineMessageArgs {
	return &SendMessageWithOneOfflineMessageArgs{}
}

func (p *SendMessageWithOneOfflineMessageArgs) GetUserIdCollection() UserIdCollection {
	return p.UserIdCollection
}

func (p *SendMessageWithOneOfflineMessageArgs) GetCmd() int16 {
	return p.Cmd
}

func (p *SendMessageWithOneOfflineMessageArgs) GetMessage() string {
	return p.Message
}
func (p *SendMessageWithOneOfflineMessageArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *SendMessageWithOneOfflineMessageArgs) ReadField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return fmt.Errorf("error reading list begin: %s", err)
	}
	tSlice := make(UserIdCollection, 0, size)
	p.UserIdCollection = tSlice
	for i := 0; i < size; i++ {
		_elem21 := &UserId{}
		if err := _elem21.Read(iprot); err != nil {
			return fmt.Errorf("%T error reading struct: %s", _elem21, err)
		}
		p.UserIdCollection = append(p.UserIdCollection, _elem21)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return fmt.Errorf("error reading list end: %s", err)
	}
	return nil
}

func (p *SendMessageWithOneOfflineMessageArgs) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI16(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Cmd = v
	}
	return nil
}

func (p *SendMessageWithOneOfflineMessageArgs) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *SendMessageWithOneOfflineMessageArgs) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("sendMessageWithOneOfflineMessage_args"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *SendMessageWithOneOfflineMessageArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("userIdCollection", thrift.LIST, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:userIdCollection: %s", p, err)
	}
	if err := oprot.WriteListBegin(thrift.STRUCT, len(p.UserIdCollection)); err != nil {
		return fmt.Errorf("error writing list begin: %s", err)
	}
	for _, v := range p.UserIdCollection {
		if err := v.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", v, err)
		}
	}
	if err := oprot.WriteListEnd(); err != nil {
		return fmt.Errorf("error writing list end: %s", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:userIdCollection: %s", p, err)
	}
	return err
}

func (p *SendMessageWithOneOfflineMessageArgs) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("cmd", thrift.I16, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:cmd: %s", p, err)
	}
	if err := oprot.WriteI16(int16(p.Cmd)); err != nil {
		return fmt.Errorf("%T.cmd (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:cmd: %s", p, err)
	}
	return err
}

func (p *SendMessageWithOneOfflineMessageArgs) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:message: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return fmt.Errorf("%T.message (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:message: %s", p, err)
	}
	return err
}

func (p *SendMessageWithOneOfflineMessageArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("SendMessageWithOneOfflineMessageArgs(%+v)", *p)
}

type SendMessageWithOneOfflineMessageResult struct {
	ErrorA1 *Error `thrift:"error,1" json:"error"`
}

func NewSendMessageWithOneOfflineMessageResult() *SendMessageWithOneOfflineMessageResult {
	return &SendMessageWithOneOfflineMessageResult{}
}

var SendMessageWithOneOfflineMessageResult_ErrorA1_DEFAULT *Error

func (p *SendMessageWithOneOfflineMessageResult) GetErrorA1() *Error {
	if !p.IsSetErrorA1() {
		return SendMessageWithOneOfflineMessageResult_ErrorA1_DEFAULT
	}
	return p.ErrorA1
}
func (p *SendMessageWithOneOfflineMessageResult) IsSetErrorA1() bool {
	return p.ErrorA1 != nil
}

func (p *SendMessageWithOneOfflineMessageResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *SendMessageWithOneOfflineMessageResult) ReadField1(iprot thrift.TProtocol) error {
	p.ErrorA1 = &Error{}
	if err := p.ErrorA1.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.ErrorA1, err)
	}
	return nil
}

func (p *SendMessageWithOneOfflineMessageResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("sendMessageWithOneOfflineMessage_result"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *SendMessageWithOneOfflineMessageResult) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetErrorA1() {
		if err := oprot.WriteFieldBegin("error", thrift.STRUCT, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:error: %s", p, err)
		}
		if err := p.ErrorA1.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.ErrorA1, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:error: %s", p, err)
		}
	}
	return err
}

func (p *SendMessageWithOneOfflineMessageResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("SendMessageWithOneOfflineMessageResult(%+v)", *p)
}

type SendMessageToRoomArgs struct {
	Nsp     string `thrift:"nsp,1" json:"nsp"`
	Room    string `thrift:"room,2" json:"room"`
	Cmd     int16  `thrift:"cmd,3" json:"cmd"`
	Message string `thrift:"message,4" json:"message"`
}

func NewSendMessageToRoomArgs() *SendMessageToRoomArgs {
	return &SendMessageToRoomArgs{}
}

func (p *SendMessageToRoomArgs) GetNsp() string {
	return p.Nsp
}

func (p *SendMessageToRoomArgs) GetRoom() string {
	return p.Room
}

func (p *SendMessageToRoomArgs) GetCmd() int16 {
	return p.Cmd
}

func (p *SendMessageToRoomArgs) GetMessage() string {
	return p.Message
}
func (p *SendMessageToRoomArgs) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		case 2:
			if err := p.ReadField2(iprot); err != nil {
				return err
			}
		case 3:
			if err := p.ReadField3(iprot); err != nil {
				return err
			}
		case 4:
			if err := p.ReadField4(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *SendMessageToRoomArgs) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 1: %s", err)
	} else {
		p.Nsp = v
	}
	return nil
}

func (p *SendMessageToRoomArgs) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 2: %s", err)
	} else {
		p.Room = v
	}
	return nil
}

func (p *SendMessageToRoomArgs) ReadField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI16(); err != nil {
		return fmt.Errorf("error reading field 3: %s", err)
	} else {
		p.Cmd = v
	}
	return nil
}

func (p *SendMessageToRoomArgs) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return fmt.Errorf("error reading field 4: %s", err)
	} else {
		p.Message = v
	}
	return nil
}

func (p *SendMessageToRoomArgs) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("sendMessageToRoom_args"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *SendMessageToRoomArgs) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("nsp", thrift.STRING, 1); err != nil {
		return fmt.Errorf("%T write field begin error 1:nsp: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Nsp)); err != nil {
		return fmt.Errorf("%T.nsp (1) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 1:nsp: %s", p, err)
	}
	return err
}

func (p *SendMessageToRoomArgs) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("room", thrift.STRING, 2); err != nil {
		return fmt.Errorf("%T write field begin error 2:room: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Room)); err != nil {
		return fmt.Errorf("%T.room (2) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 2:room: %s", p, err)
	}
	return err
}

func (p *SendMessageToRoomArgs) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("cmd", thrift.I16, 3); err != nil {
		return fmt.Errorf("%T write field begin error 3:cmd: %s", p, err)
	}
	if err := oprot.WriteI16(int16(p.Cmd)); err != nil {
		return fmt.Errorf("%T.cmd (3) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 3:cmd: %s", p, err)
	}
	return err
}

func (p *SendMessageToRoomArgs) writeField4(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("message", thrift.STRING, 4); err != nil {
		return fmt.Errorf("%T write field begin error 4:message: %s", p, err)
	}
	if err := oprot.WriteString(string(p.Message)); err != nil {
		return fmt.Errorf("%T.message (4) field write error: %s", p, err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return fmt.Errorf("%T write field end error 4:message: %s", p, err)
	}
	return err
}

func (p *SendMessageToRoomArgs) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("SendMessageToRoomArgs(%+v)", *p)
}

type SendMessageToRoomResult struct {
	ErrorA1 *Error `thrift:"error,1" json:"error"`
}

func NewSendMessageToRoomResult() *SendMessageToRoomResult {
	return &SendMessageToRoomResult{}
}

var SendMessageToRoomResult_ErrorA1_DEFAULT *Error

func (p *SendMessageToRoomResult) GetErrorA1() *Error {
	if !p.IsSetErrorA1() {
		return SendMessageToRoomResult_ErrorA1_DEFAULT
	}
	return p.ErrorA1
}
func (p *SendMessageToRoomResult) IsSetErrorA1() bool {
	return p.ErrorA1 != nil
}

func (p *SendMessageToRoomResult) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return fmt.Errorf("%T read error: %s", p, err)
	}
	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return fmt.Errorf("%T field %d read error: %s", p, fieldId, err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if err := p.ReadField1(iprot); err != nil {
				return err
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return fmt.Errorf("%T read struct end error: %s", p, err)
	}
	return nil
}

func (p *SendMessageToRoomResult) ReadField1(iprot thrift.TProtocol) error {
	p.ErrorA1 = &Error{}
	if err := p.ErrorA1.Read(iprot); err != nil {
		return fmt.Errorf("%T error reading struct: %s", p.ErrorA1, err)
	}
	return nil
}

func (p *SendMessageToRoomResult) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("sendMessageToRoom_result"); err != nil {
		return fmt.Errorf("%T write struct begin error: %s", p, err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := oprot.WriteFieldStop(); err != nil {
		return fmt.Errorf("write field stop error: %s", err)
	}
	if err := oprot.WriteStructEnd(); err != nil {
		return fmt.Errorf("write struct stop error: %s", err)
	}
	return nil
}

func (p *SendMessageToRoomResult) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetErrorA1() {
		if err := oprot.WriteFieldBegin("error", thrift.STRUCT, 1); err != nil {
			return fmt.Errorf("%T write field begin error 1:error: %s", p, err)
		}
		if err := p.ErrorA1.Write(oprot); err != nil {
			return fmt.Errorf("%T error writing struct: %s", p.ErrorA1, err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return fmt.Errorf("%T write field end error 1:error: %s", p, err)
		}
	}
	return err
}

func (p *SendMessageToRoomResult) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("SendMessageToRoomResult(%+v)", *p)
}