QueryF.tars.go

// Package queryf comment
// This file was generated by tars2go 1.1.5
// Generated from QueryF.tars
package queryf

import (
	"bytes"
	"context"
	"encoding/json"
	"github.com/TarsCloud/TarsGo/tars/protocol/res/endpointf"
	"fmt"
	m "github.com/TarsCloud/TarsGo/tars/model"
	"github.com/TarsCloud/TarsGo/tars/protocol/codec"
	"github.com/TarsCloud/TarsGo/tars/protocol/res/basef"
	"github.com/TarsCloud/TarsGo/tars/protocol/res/requestf"
	"github.com/TarsCloud/TarsGo/tars/protocol/tup"
	"github.com/TarsCloud/TarsGo/tars/util/current"
	"github.com/TarsCloud/TarsGo/tars/util/tools"
	"unsafe"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = fmt.Errorf
var _ = codec.FromInt8
var _ = unsafe.Pointer(nil)
var _ = bytes.ErrTooLarge

//QueryF struct
type QueryF struct {
	s m.Servant
}

//FindObjectById is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectById(id string, _opt ...map[string]string) (ret []endpointf.EndpointF, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)
	tarsCtx := context.Background()

	err = _obj.s.Tars_invoke(tarsCtx, 0, "findObjectById", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	_is := codec.NewReader(tools.Int8ToByte(_resp.SBuffer))
	_, ty, err = _is.SkipToNoCheck(0, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		ret = make([]endpointf.EndpointF, length)
		for i0, e0 := int32(0), length; i0 < e0; i0++ {

			err = ret[i0].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectByIdWithContext is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectByIdWithContext(tarsCtx context.Context, id string, _opt ...map[string]string) (ret []endpointf.EndpointF, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)

	err = _obj.s.Tars_invoke(tarsCtx, 0, "findObjectById", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	_is := codec.NewReader(tools.Int8ToByte(_resp.SBuffer))
	_, ty, err = _is.SkipToNoCheck(0, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		ret = make([]endpointf.EndpointF, length)
		for i1, e1 := int32(0), length; i1 < e1; i1++ {

			err = ret[i1].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectByIdOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectByIdOneWayWithContext(tarsCtx context.Context, id string, _opt ...map[string]string) (ret []endpointf.EndpointF, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)

	err = _obj.s.Tars_invoke(tarsCtx, 1, "findObjectById", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectById4Any is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectById4Any(id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)
	tarsCtx := context.Background()

	err = _obj.s.Tars_invoke(tarsCtx, 0, "findObjectById4Any", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	_is := codec.NewReader(tools.Int8ToByte(_resp.SBuffer))
	err = _is.Read_int32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = _is.SkipToNoCheck(2, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*activeEp) = make([]endpointf.EndpointF, length)
		for i2, e2 := int32(0), length; i2 < e2; i2++ {

			err = (*activeEp)[i2].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	_, ty, err = _is.SkipToNoCheck(3, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*inactiveEp) = make([]endpointf.EndpointF, length)
		for i3, e3 := int32(0), length; i3 < e3; i3++ {

			err = (*inactiveEp)[i3].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectById4AnyWithContext is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectById4AnyWithContext(tarsCtx context.Context, id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)

	err = _obj.s.Tars_invoke(tarsCtx, 0, "findObjectById4Any", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	_is := codec.NewReader(tools.Int8ToByte(_resp.SBuffer))
	err = _is.Read_int32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = _is.SkipToNoCheck(2, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*activeEp) = make([]endpointf.EndpointF, length)
		for i4, e4 := int32(0), length; i4 < e4; i4++ {

			err = (*activeEp)[i4].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	_, ty, err = _is.SkipToNoCheck(3, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*inactiveEp) = make([]endpointf.EndpointF, length)
		for i5, e5 := int32(0), length; i5 < e5; i5++ {

			err = (*inactiveEp)[i5].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectById4AnyOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectById4AnyOneWayWithContext(tarsCtx context.Context, id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)

	err = _obj.s.Tars_invoke(tarsCtx, 1, "findObjectById4Any", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectById4All is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectById4All(id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)
	tarsCtx := context.Background()

	err = _obj.s.Tars_invoke(tarsCtx, 0, "findObjectById4All", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	_is := codec.NewReader(tools.Int8ToByte(_resp.SBuffer))
	err = _is.Read_int32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = _is.SkipToNoCheck(2, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*activeEp) = make([]endpointf.EndpointF, length)
		for i6, e6 := int32(0), length; i6 < e6; i6++ {

			err = (*activeEp)[i6].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	_, ty, err = _is.SkipToNoCheck(3, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*inactiveEp) = make([]endpointf.EndpointF, length)
		for i7, e7 := int32(0), length; i7 < e7; i7++ {

			err = (*inactiveEp)[i7].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectById4AllWithContext is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectById4AllWithContext(tarsCtx context.Context, id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)

	err = _obj.s.Tars_invoke(tarsCtx, 0, "findObjectById4All", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	_is := codec.NewReader(tools.Int8ToByte(_resp.SBuffer))
	err = _is.Read_int32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = _is.SkipToNoCheck(2, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*activeEp) = make([]endpointf.EndpointF, length)
		for i8, e8 := int32(0), length; i8 < e8; i8++ {

			err = (*activeEp)[i8].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	_, ty, err = _is.SkipToNoCheck(3, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*inactiveEp) = make([]endpointf.EndpointF, length)
		for i9, e9 := int32(0), length; i9 < e9; i9++ {

			err = (*inactiveEp)[i9].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectById4AllOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectById4AllOneWayWithContext(tarsCtx context.Context, id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)

	err = _obj.s.Tars_invoke(tarsCtx, 1, "findObjectById4All", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectByIdInSameGroup is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectByIdInSameGroup(id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)
	tarsCtx := context.Background()

	err = _obj.s.Tars_invoke(tarsCtx, 0, "findObjectByIdInSameGroup", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	_is := codec.NewReader(tools.Int8ToByte(_resp.SBuffer))
	err = _is.Read_int32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = _is.SkipToNoCheck(2, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*activeEp) = make([]endpointf.EndpointF, length)
		for i10, e10 := int32(0), length; i10 < e10; i10++ {

			err = (*activeEp)[i10].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	_, ty, err = _is.SkipToNoCheck(3, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*inactiveEp) = make([]endpointf.EndpointF, length)
		for i11, e11 := int32(0), length; i11 < e11; i11++ {

			err = (*inactiveEp)[i11].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectByIdInSameGroupWithContext is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectByIdInSameGroupWithContext(tarsCtx context.Context, id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)

	err = _obj.s.Tars_invoke(tarsCtx, 0, "findObjectByIdInSameGroup", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	_is := codec.NewReader(tools.Int8ToByte(_resp.SBuffer))
	err = _is.Read_int32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = _is.SkipToNoCheck(2, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*activeEp) = make([]endpointf.EndpointF, length)
		for i12, e12 := int32(0), length; i12 < e12; i12++ {

			err = (*activeEp)[i12].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	_, ty, err = _is.SkipToNoCheck(3, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*inactiveEp) = make([]endpointf.EndpointF, length)
		for i13, e13 := int32(0), length; i13 < e13; i13++ {

			err = (*inactiveEp)[i13].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectByIdInSameGroupOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectByIdInSameGroupOneWayWithContext(tarsCtx context.Context, id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)

	err = _obj.s.Tars_invoke(tarsCtx, 1, "findObjectByIdInSameGroup", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectByIdInSameStation is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectByIdInSameStation(id string, sStation string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.Write_string(sStation, 2)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 4)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)
	tarsCtx := context.Background()

	err = _obj.s.Tars_invoke(tarsCtx, 0, "findObjectByIdInSameStation", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	_is := codec.NewReader(tools.Int8ToByte(_resp.SBuffer))
	err = _is.Read_int32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = _is.SkipToNoCheck(3, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*activeEp) = make([]endpointf.EndpointF, length)
		for i14, e14 := int32(0), length; i14 < e14; i14++ {

			err = (*activeEp)[i14].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	_, ty, err = _is.SkipToNoCheck(4, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*inactiveEp) = make([]endpointf.EndpointF, length)
		for i15, e15 := int32(0), length; i15 < e15; i15++ {

			err = (*inactiveEp)[i15].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectByIdInSameStationWithContext is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectByIdInSameStationWithContext(tarsCtx context.Context, id string, sStation string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.Write_string(sStation, 2)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 4)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)

	err = _obj.s.Tars_invoke(tarsCtx, 0, "findObjectByIdInSameStation", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	_is := codec.NewReader(tools.Int8ToByte(_resp.SBuffer))
	err = _is.Read_int32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = _is.SkipToNoCheck(3, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*activeEp) = make([]endpointf.EndpointF, length)
		for i16, e16 := int32(0), length; i16 < e16; i16++ {

			err = (*activeEp)[i16].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	_, ty, err = _is.SkipToNoCheck(4, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*inactiveEp) = make([]endpointf.EndpointF, length)
		for i17, e17 := int32(0), length; i17 < e17; i17++ {

			err = (*inactiveEp)[i17].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectByIdInSameStationOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectByIdInSameStationOneWayWithContext(tarsCtx context.Context, id string, sStation string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.Write_string(sStation, 2)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 4)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)

	err = _obj.s.Tars_invoke(tarsCtx, 1, "findObjectByIdInSameStation", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectByIdInSameSet is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectByIdInSameSet(id string, setId string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.Write_string(setId, 2)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 4)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)
	tarsCtx := context.Background()

	err = _obj.s.Tars_invoke(tarsCtx, 0, "findObjectByIdInSameSet", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	_is := codec.NewReader(tools.Int8ToByte(_resp.SBuffer))
	err = _is.Read_int32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = _is.SkipToNoCheck(3, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*activeEp) = make([]endpointf.EndpointF, length)
		for i18, e18 := int32(0), length; i18 < e18; i18++ {

			err = (*activeEp)[i18].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	_, ty, err = _is.SkipToNoCheck(4, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*inactiveEp) = make([]endpointf.EndpointF, length)
		for i19, e19 := int32(0), length; i19 < e19; i19++ {

			err = (*inactiveEp)[i19].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectByIdInSameSetWithContext is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectByIdInSameSetWithContext(tarsCtx context.Context, id string, setId string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.Write_string(setId, 2)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 4)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)

	err = _obj.s.Tars_invoke(tarsCtx, 0, "findObjectByIdInSameSet", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	_is := codec.NewReader(tools.Int8ToByte(_resp.SBuffer))
	err = _is.Read_int32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = _is.SkipToNoCheck(3, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*activeEp) = make([]endpointf.EndpointF, length)
		for i20, e20 := int32(0), length; i20 < e20; i20++ {

			err = (*activeEp)[i20].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	_, ty, err = _is.SkipToNoCheck(4, true)
	if err != nil {
		return ret, err
	}

	if ty == codec.LIST {
		err = _is.Read_int32(&length, 0, true)
		if err != nil {
			return ret, err
		}

		(*inactiveEp) = make([]endpointf.EndpointF, length)
		for i21, e21 := int32(0), length; i21 < e21; i21++ {

			err = (*inactiveEp)[i21].ReadBlock(_is, 0, false)
			if err != nil {
				return ret, err
			}

		}
	} else if ty == codec.SIMPLE_LIST {
		err = fmt.Errorf("not support simple_list type")
		if err != nil {
			return ret, err
		}

	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}

	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//FindObjectByIdInSameSetOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (_obj *QueryF) FindObjectByIdInSameSetOneWayWithContext(tarsCtx context.Context, id string, setId string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF, _opt ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_os := codec.NewBuffer()
	err = _os.Write_string(id, 1)
	if err != nil {
		return ret, err
	}

	err = _os.Write_string(setId, 2)
	if err != nil {
		return ret, err
	}

	err = _os.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*activeEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *activeEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	err = _os.WriteHead(codec.LIST, 4)
	if err != nil {
		return ret, err
	}

	err = _os.Write_int32(int32(len((*inactiveEp))), 0)
	if err != nil {
		return ret, err
	}

	for _, v := range *inactiveEp {

		err = v.WriteBlock(_os, 0)
		if err != nil {
			return ret, err
		}

	}

	var _status map[string]string
	var _context map[string]string
	if len(_opt) == 1 {
		_context = _opt[0]
	} else if len(_opt) == 2 {
		_context = _opt[0]
		_status = _opt[1]
	}
	_resp := new(requestf.ResponsePacket)

	err = _obj.s.Tars_invoke(tarsCtx, 1, "findObjectByIdInSameSet", _os.ToBytes(), _status, _context, _resp)
	if err != nil {
		return ret, err
	}

	if len(_opt) == 1 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
	} else if len(_opt) == 2 {
		for k := range _context {
			delete(_context, k)
		}
		for k, v := range _resp.Context {
			_context[k] = v
		}
		for k := range _status {
			delete(_status, k)
		}
		for k, v := range _resp.Status {
			_status[k] = v
		}

	}
	_ = length
	_ = have
	_ = ty
	return ret, nil
}

//SetServant sets servant for the service.
func (_obj *QueryF) SetServant(s m.Servant) {
	_obj.s = s
}

//TarsSetTimeout sets the timeout for the servant which is in ms.
func (_obj *QueryF) TarsSetTimeout(t int) {
	_obj.s.TarsSetTimeout(t)
}

//TarsSetProtocol sets the protocol for the servant.
func (_obj *QueryF) TarsSetProtocol(p m.Protocol) {
	_obj.s.TarsSetProtocol(p)
}

type _impQueryF interface {
	FindObjectById(id string) (ret []endpointf.EndpointF, err error)
	FindObjectById4Any(id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF) (ret int32, err error)
	FindObjectById4All(id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF) (ret int32, err error)
	FindObjectByIdInSameGroup(id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF) (ret int32, err error)
	FindObjectByIdInSameStation(id string, sStation string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF) (ret int32, err error)
	FindObjectByIdInSameSet(id string, setId string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF) (ret int32, err error)
}
type _impQueryFWithContext interface {
	FindObjectById(tarsCtx context.Context, id string) (ret []endpointf.EndpointF, err error)
	FindObjectById4Any(tarsCtx context.Context, id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF) (ret int32, err error)
	FindObjectById4All(tarsCtx context.Context, id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF) (ret int32, err error)
	FindObjectByIdInSameGroup(tarsCtx context.Context, id string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF) (ret int32, err error)
	FindObjectByIdInSameStation(tarsCtx context.Context, id string, sStation string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF) (ret int32, err error)
	FindObjectByIdInSameSet(tarsCtx context.Context, id string, setId string, activeEp *[]endpointf.EndpointF, inactiveEp *[]endpointf.EndpointF) (ret int32, err error)
}

// Dispatch is used to call the server side implement for the method defined in the tars file. _withContext shows using context or not.
func (_obj *QueryF) Dispatch(tarsCtx context.Context, _val interface{}, tarsReq *requestf.RequestPacket, tarsResp *requestf.ResponsePacket, _withContext bool) (err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	_is := codec.NewReader(tools.Int8ToByte(tarsReq.SBuffer))
	_os := codec.NewBuffer()
	switch tarsReq.SFuncName {
	case "findObjectById":
		var id string

		if tarsReq.IVersion == basef.TARSVERSION {

			err = _is.Read_string(&id, 1, true)
			if err != nil {
				return err
			}

		} else if tarsReq.IVersion == basef.TUPVERSION {
			_reqTup_ := tup.NewUniAttribute()
			_reqTup_.Decode(_is)

			var _tupBuffer_ []byte

			_reqTup_.GetBuffer("id", &_tupBuffer_)
			_is.Reset(_tupBuffer_)
			err = _is.Read_string(&id, 0, true)
			if err != nil {
				return err
			}

		} else if tarsReq.IVersion == basef.JSONVERSION {
			var _jsonDat_ map[string]interface{}
			_decoder_ := json.NewDecoder(bytes.NewReader(_is.ToBytes()))
			_decoder_.UseNumber()
			err = _decoder_.Decode(&_jsonDat_)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				_jsonStr_, _ := json.Marshal(_jsonDat_["id"])
				if err = json.Unmarshal([]byte(_jsonStr_), &id); err != nil {
					return err
				}
			}

		} else {
			err = fmt.Errorf("decode reqpacket fail, error version: %d", tarsReq.IVersion)
			return err
		}

		var _funRet_ []endpointf.EndpointF
		if !_withContext {
			_imp := _val.(_impQueryF)
			_funRet_, err = _imp.FindObjectById(id)
		} else {
			_imp := _val.(_impQueryFWithContext)
			_funRet_, err = _imp.FindObjectById(tarsCtx, id)
		}

		if err != nil {
			return err
		}

		if tarsReq.IVersion == basef.TARSVERSION {
			_os.Reset()

			err = _os.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(_funRet_)), 0)
			if err != nil {
				return err
			}

			for _, v := range _funRet_ {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}

		} else if tarsReq.IVersion == basef.TUPVERSION {
			_tupRsp_ := tup.NewUniAttribute()

			err = _os.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(_funRet_)), 0)
			if err != nil {
				return err
			}

			for _, v := range _funRet_ {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}

			_tupRsp_.PutBuffer("", _os.ToBytes())
			_tupRsp_.PutBuffer("tars_ret", _os.ToBytes())

			_os.Reset()
			err = _tupRsp_.Encode(_os)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			_rspJson_ := map[string]interface{}{}
			_rspJson_["tars_ret"] = _funRet_

			var _rspByte_ []byte
			if _rspByte_, err = json.Marshal(_rspJson_); err != nil {
				return err
			}

			_os.Reset()
			err = _os.Write_slice_uint8(_rspByte_)
			if err != nil {
				return err
			}
		}
	case "findObjectById4Any":
		var id string
		var activeEp []endpointf.EndpointF
		var inactiveEp []endpointf.EndpointF

		if tarsReq.IVersion == basef.TARSVERSION {

			err = _is.Read_string(&id, 1, true)
			if err != nil {
				return err
			}

		} else if tarsReq.IVersion == basef.TUPVERSION {
			_reqTup_ := tup.NewUniAttribute()
			_reqTup_.Decode(_is)

			var _tupBuffer_ []byte

			_reqTup_.GetBuffer("id", &_tupBuffer_)
			_is.Reset(_tupBuffer_)
			err = _is.Read_string(&id, 0, true)
			if err != nil {
				return err
			}

		} else if tarsReq.IVersion == basef.JSONVERSION {
			var _jsonDat_ map[string]interface{}
			_decoder_ := json.NewDecoder(bytes.NewReader(_is.ToBytes()))
			_decoder_.UseNumber()
			err = _decoder_.Decode(&_jsonDat_)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				_jsonStr_, _ := json.Marshal(_jsonDat_["id"])
				if err = json.Unmarshal([]byte(_jsonStr_), &id); err != nil {
					return err
				}
			}

		} else {
			err = fmt.Errorf("decode reqpacket fail, error version: %d", tarsReq.IVersion)
			return err
		}

		var _funRet_ int32
		if !_withContext {
			_imp := _val.(_impQueryF)
			_funRet_, err = _imp.FindObjectById4Any(id, &activeEp, &inactiveEp)
		} else {
			_imp := _val.(_impQueryFWithContext)
			_funRet_, err = _imp.FindObjectById4Any(tarsCtx, id, &activeEp, &inactiveEp)
		}

		if err != nil {
			return err
		}

		if tarsReq.IVersion == basef.TARSVERSION {
			_os.Reset()

			err = _os.Write_int32(_funRet_, 0)
			if err != nil {
				return err
			}

			err = _os.WriteHead(codec.LIST, 2)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(activeEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range activeEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}

			err = _os.WriteHead(codec.LIST, 3)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(inactiveEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range inactiveEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}

		} else if tarsReq.IVersion == basef.TUPVERSION {
			_tupRsp_ := tup.NewUniAttribute()

			err = _os.Write_int32(_funRet_, 0)
			if err != nil {
				return err
			}

			_tupRsp_.PutBuffer("", _os.ToBytes())
			_tupRsp_.PutBuffer("tars_ret", _os.ToBytes())

			_os.Reset()
			err = _os.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(activeEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range activeEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}
			_tupRsp_.PutBuffer("activeEp", _os.ToBytes())

			_os.Reset()
			err = _os.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(inactiveEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range inactiveEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}
			_tupRsp_.PutBuffer("inactiveEp", _os.ToBytes())

			_os.Reset()
			err = _tupRsp_.Encode(_os)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			_rspJson_ := map[string]interface{}{}
			_rspJson_["tars_ret"] = _funRet_
			_rspJson_["activeEp"] = activeEp
			_rspJson_["inactiveEp"] = inactiveEp

			var _rspByte_ []byte
			if _rspByte_, err = json.Marshal(_rspJson_); err != nil {
				return err
			}

			_os.Reset()
			err = _os.Write_slice_uint8(_rspByte_)
			if err != nil {
				return err
			}
		}
	case "findObjectById4All":
		var id string
		var activeEp []endpointf.EndpointF
		var inactiveEp []endpointf.EndpointF

		if tarsReq.IVersion == basef.TARSVERSION {

			err = _is.Read_string(&id, 1, true)
			if err != nil {
				return err
			}

		} else if tarsReq.IVersion == basef.TUPVERSION {
			_reqTup_ := tup.NewUniAttribute()
			_reqTup_.Decode(_is)

			var _tupBuffer_ []byte

			_reqTup_.GetBuffer("id", &_tupBuffer_)
			_is.Reset(_tupBuffer_)
			err = _is.Read_string(&id, 0, true)
			if err != nil {
				return err
			}

		} else if tarsReq.IVersion == basef.JSONVERSION {
			var _jsonDat_ map[string]interface{}
			_decoder_ := json.NewDecoder(bytes.NewReader(_is.ToBytes()))
			_decoder_.UseNumber()
			err = _decoder_.Decode(&_jsonDat_)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				_jsonStr_, _ := json.Marshal(_jsonDat_["id"])
				if err = json.Unmarshal([]byte(_jsonStr_), &id); err != nil {
					return err
				}
			}

		} else {
			err = fmt.Errorf("decode reqpacket fail, error version: %d", tarsReq.IVersion)
			return err
		}

		var _funRet_ int32
		if !_withContext {
			_imp := _val.(_impQueryF)
			_funRet_, err = _imp.FindObjectById4All(id, &activeEp, &inactiveEp)
		} else {
			_imp := _val.(_impQueryFWithContext)
			_funRet_, err = _imp.FindObjectById4All(tarsCtx, id, &activeEp, &inactiveEp)
		}

		if err != nil {
			return err
		}

		if tarsReq.IVersion == basef.TARSVERSION {
			_os.Reset()

			err = _os.Write_int32(_funRet_, 0)
			if err != nil {
				return err
			}

			err = _os.WriteHead(codec.LIST, 2)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(activeEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range activeEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}

			err = _os.WriteHead(codec.LIST, 3)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(inactiveEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range inactiveEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}

		} else if tarsReq.IVersion == basef.TUPVERSION {
			_tupRsp_ := tup.NewUniAttribute()

			err = _os.Write_int32(_funRet_, 0)
			if err != nil {
				return err
			}

			_tupRsp_.PutBuffer("", _os.ToBytes())
			_tupRsp_.PutBuffer("tars_ret", _os.ToBytes())

			_os.Reset()
			err = _os.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(activeEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range activeEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}
			_tupRsp_.PutBuffer("activeEp", _os.ToBytes())

			_os.Reset()
			err = _os.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(inactiveEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range inactiveEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}
			_tupRsp_.PutBuffer("inactiveEp", _os.ToBytes())

			_os.Reset()
			err = _tupRsp_.Encode(_os)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			_rspJson_ := map[string]interface{}{}
			_rspJson_["tars_ret"] = _funRet_
			_rspJson_["activeEp"] = activeEp
			_rspJson_["inactiveEp"] = inactiveEp

			var _rspByte_ []byte
			if _rspByte_, err = json.Marshal(_rspJson_); err != nil {
				return err
			}

			_os.Reset()
			err = _os.Write_slice_uint8(_rspByte_)
			if err != nil {
				return err
			}
		}
	case "findObjectByIdInSameGroup":
		var id string
		var activeEp []endpointf.EndpointF
		var inactiveEp []endpointf.EndpointF

		if tarsReq.IVersion == basef.TARSVERSION {

			err = _is.Read_string(&id, 1, true)
			if err != nil {
				return err
			}

		} else if tarsReq.IVersion == basef.TUPVERSION {
			_reqTup_ := tup.NewUniAttribute()
			_reqTup_.Decode(_is)

			var _tupBuffer_ []byte

			_reqTup_.GetBuffer("id", &_tupBuffer_)
			_is.Reset(_tupBuffer_)
			err = _is.Read_string(&id, 0, true)
			if err != nil {
				return err
			}

		} else if tarsReq.IVersion == basef.JSONVERSION {
			var _jsonDat_ map[string]interface{}
			_decoder_ := json.NewDecoder(bytes.NewReader(_is.ToBytes()))
			_decoder_.UseNumber()
			err = _decoder_.Decode(&_jsonDat_)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				_jsonStr_, _ := json.Marshal(_jsonDat_["id"])
				if err = json.Unmarshal([]byte(_jsonStr_), &id); err != nil {
					return err
				}
			}

		} else {
			err = fmt.Errorf("decode reqpacket fail, error version: %d", tarsReq.IVersion)
			return err
		}

		var _funRet_ int32
		if !_withContext {
			_imp := _val.(_impQueryF)
			_funRet_, err = _imp.FindObjectByIdInSameGroup(id, &activeEp, &inactiveEp)
		} else {
			_imp := _val.(_impQueryFWithContext)
			_funRet_, err = _imp.FindObjectByIdInSameGroup(tarsCtx, id, &activeEp, &inactiveEp)
		}

		if err != nil {
			return err
		}

		if tarsReq.IVersion == basef.TARSVERSION {
			_os.Reset()

			err = _os.Write_int32(_funRet_, 0)
			if err != nil {
				return err
			}

			err = _os.WriteHead(codec.LIST, 2)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(activeEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range activeEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}

			err = _os.WriteHead(codec.LIST, 3)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(inactiveEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range inactiveEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}

		} else if tarsReq.IVersion == basef.TUPVERSION {
			_tupRsp_ := tup.NewUniAttribute()

			err = _os.Write_int32(_funRet_, 0)
			if err != nil {
				return err
			}

			_tupRsp_.PutBuffer("", _os.ToBytes())
			_tupRsp_.PutBuffer("tars_ret", _os.ToBytes())

			_os.Reset()
			err = _os.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(activeEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range activeEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}
			_tupRsp_.PutBuffer("activeEp", _os.ToBytes())

			_os.Reset()
			err = _os.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(inactiveEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range inactiveEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}
			_tupRsp_.PutBuffer("inactiveEp", _os.ToBytes())

			_os.Reset()
			err = _tupRsp_.Encode(_os)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			_rspJson_ := map[string]interface{}{}
			_rspJson_["tars_ret"] = _funRet_
			_rspJson_["activeEp"] = activeEp
			_rspJson_["inactiveEp"] = inactiveEp

			var _rspByte_ []byte
			if _rspByte_, err = json.Marshal(_rspJson_); err != nil {
				return err
			}

			_os.Reset()
			err = _os.Write_slice_uint8(_rspByte_)
			if err != nil {
				return err
			}
		}
	case "findObjectByIdInSameStation":
		var id string
		var sStation string
		var activeEp []endpointf.EndpointF
		var inactiveEp []endpointf.EndpointF

		if tarsReq.IVersion == basef.TARSVERSION {

			err = _is.Read_string(&id, 1, true)
			if err != nil {
				return err
			}

			err = _is.Read_string(&sStation, 2, true)
			if err != nil {
				return err
			}

		} else if tarsReq.IVersion == basef.TUPVERSION {
			_reqTup_ := tup.NewUniAttribute()
			_reqTup_.Decode(_is)

			var _tupBuffer_ []byte

			_reqTup_.GetBuffer("id", &_tupBuffer_)
			_is.Reset(_tupBuffer_)
			err = _is.Read_string(&id, 0, true)
			if err != nil {
				return err
			}

			_reqTup_.GetBuffer("sStation", &_tupBuffer_)
			_is.Reset(_tupBuffer_)
			err = _is.Read_string(&sStation, 0, true)
			if err != nil {
				return err
			}

		} else if tarsReq.IVersion == basef.JSONVERSION {
			var _jsonDat_ map[string]interface{}
			_decoder_ := json.NewDecoder(bytes.NewReader(_is.ToBytes()))
			_decoder_.UseNumber()
			err = _decoder_.Decode(&_jsonDat_)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				_jsonStr_, _ := json.Marshal(_jsonDat_["id"])
				if err = json.Unmarshal([]byte(_jsonStr_), &id); err != nil {
					return err
				}
			}
			{
				_jsonStr_, _ := json.Marshal(_jsonDat_["sStation"])
				if err = json.Unmarshal([]byte(_jsonStr_), &sStation); err != nil {
					return err
				}
			}

		} else {
			err = fmt.Errorf("decode reqpacket fail, error version: %d", tarsReq.IVersion)
			return err
		}

		var _funRet_ int32
		if !_withContext {
			_imp := _val.(_impQueryF)
			_funRet_, err = _imp.FindObjectByIdInSameStation(id, sStation, &activeEp, &inactiveEp)
		} else {
			_imp := _val.(_impQueryFWithContext)
			_funRet_, err = _imp.FindObjectByIdInSameStation(tarsCtx, id, sStation, &activeEp, &inactiveEp)
		}

		if err != nil {
			return err
		}

		if tarsReq.IVersion == basef.TARSVERSION {
			_os.Reset()

			err = _os.Write_int32(_funRet_, 0)
			if err != nil {
				return err
			}

			err = _os.WriteHead(codec.LIST, 3)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(activeEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range activeEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}

			err = _os.WriteHead(codec.LIST, 4)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(inactiveEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range inactiveEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}

		} else if tarsReq.IVersion == basef.TUPVERSION {
			_tupRsp_ := tup.NewUniAttribute()

			err = _os.Write_int32(_funRet_, 0)
			if err != nil {
				return err
			}

			_tupRsp_.PutBuffer("", _os.ToBytes())
			_tupRsp_.PutBuffer("tars_ret", _os.ToBytes())

			_os.Reset()
			err = _os.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(activeEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range activeEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}
			_tupRsp_.PutBuffer("activeEp", _os.ToBytes())

			_os.Reset()
			err = _os.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(inactiveEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range inactiveEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}
			_tupRsp_.PutBuffer("inactiveEp", _os.ToBytes())

			_os.Reset()
			err = _tupRsp_.Encode(_os)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			_rspJson_ := map[string]interface{}{}
			_rspJson_["tars_ret"] = _funRet_
			_rspJson_["activeEp"] = activeEp
			_rspJson_["inactiveEp"] = inactiveEp

			var _rspByte_ []byte
			if _rspByte_, err = json.Marshal(_rspJson_); err != nil {
				return err
			}

			_os.Reset()
			err = _os.Write_slice_uint8(_rspByte_)
			if err != nil {
				return err
			}
		}
	case "findObjectByIdInSameSet":
		var id string
		var setId string
		var activeEp []endpointf.EndpointF
		var inactiveEp []endpointf.EndpointF

		if tarsReq.IVersion == basef.TARSVERSION {

			err = _is.Read_string(&id, 1, true)
			if err != nil {
				return err
			}

			err = _is.Read_string(&setId, 2, true)
			if err != nil {
				return err
			}

		} else if tarsReq.IVersion == basef.TUPVERSION {
			_reqTup_ := tup.NewUniAttribute()
			_reqTup_.Decode(_is)

			var _tupBuffer_ []byte

			_reqTup_.GetBuffer("id", &_tupBuffer_)
			_is.Reset(_tupBuffer_)
			err = _is.Read_string(&id, 0, true)
			if err != nil {
				return err
			}

			_reqTup_.GetBuffer("setId", &_tupBuffer_)
			_is.Reset(_tupBuffer_)
			err = _is.Read_string(&setId, 0, true)
			if err != nil {
				return err
			}

		} else if tarsReq.IVersion == basef.JSONVERSION {
			var _jsonDat_ map[string]interface{}
			_decoder_ := json.NewDecoder(bytes.NewReader(_is.ToBytes()))
			_decoder_.UseNumber()
			err = _decoder_.Decode(&_jsonDat_)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				_jsonStr_, _ := json.Marshal(_jsonDat_["id"])
				if err = json.Unmarshal([]byte(_jsonStr_), &id); err != nil {
					return err
				}
			}
			{
				_jsonStr_, _ := json.Marshal(_jsonDat_["setId"])
				if err = json.Unmarshal([]byte(_jsonStr_), &setId); err != nil {
					return err
				}
			}

		} else {
			err = fmt.Errorf("decode reqpacket fail, error version: %d", tarsReq.IVersion)
			return err
		}

		var _funRet_ int32
		if !_withContext {
			_imp := _val.(_impQueryF)
			_funRet_, err = _imp.FindObjectByIdInSameSet(id, setId, &activeEp, &inactiveEp)
		} else {
			_imp := _val.(_impQueryFWithContext)
			_funRet_, err = _imp.FindObjectByIdInSameSet(tarsCtx, id, setId, &activeEp, &inactiveEp)
		}

		if err != nil {
			return err
		}

		if tarsReq.IVersion == basef.TARSVERSION {
			_os.Reset()

			err = _os.Write_int32(_funRet_, 0)
			if err != nil {
				return err
			}

			err = _os.WriteHead(codec.LIST, 3)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(activeEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range activeEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}

			err = _os.WriteHead(codec.LIST, 4)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(inactiveEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range inactiveEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}

		} else if tarsReq.IVersion == basef.TUPVERSION {
			_tupRsp_ := tup.NewUniAttribute()

			err = _os.Write_int32(_funRet_, 0)
			if err != nil {
				return err
			}

			_tupRsp_.PutBuffer("", _os.ToBytes())
			_tupRsp_.PutBuffer("tars_ret", _os.ToBytes())

			_os.Reset()
			err = _os.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(activeEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range activeEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}
			_tupRsp_.PutBuffer("activeEp", _os.ToBytes())

			_os.Reset()
			err = _os.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}

			err = _os.Write_int32(int32(len(inactiveEp)), 0)
			if err != nil {
				return err
			}

			for _, v := range inactiveEp {

				err = v.WriteBlock(_os, 0)
				if err != nil {
					return err
				}

			}
			_tupRsp_.PutBuffer("inactiveEp", _os.ToBytes())

			_os.Reset()
			err = _tupRsp_.Encode(_os)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			_rspJson_ := map[string]interface{}{}
			_rspJson_["tars_ret"] = _funRet_
			_rspJson_["activeEp"] = activeEp
			_rspJson_["inactiveEp"] = inactiveEp

			var _rspByte_ []byte
			if _rspByte_, err = json.Marshal(_rspJson_); err != nil {
				return err
			}

			_os.Reset()
			err = _os.Write_slice_uint8(_rspByte_)
			if err != nil {
				return err
			}
		}

	default:
		return fmt.Errorf("func mismatch")
	}
	var _status map[string]string
	s, ok := current.GetResponseStatus(tarsCtx)
	if ok && s != nil {
		_status = s
	}
	var _context map[string]string
	c, ok := current.GetResponseContext(tarsCtx)
	if ok && c != nil {
		_context = c
	}
	*tarsResp = requestf.ResponsePacket{
		IVersion:     tarsReq.IVersion,
		CPacketType:  0,
		IRequestId:   tarsReq.IRequestId,
		IMessageType: 0,
		IRet:         0,
		SBuffer:      tools.ByteToInt8(_os.ToBytes()),
		Status:       _status,
		SResultDesc:  "",
		Context:      _context,
	}

	_ = _is
	_ = _os
	_ = length
	_ = have
	_ = ty
	return nil
}