Config.tars.go

// Code generated by tars2go 1.2.3, DO NOT EDIT.
// This file was generated from ConfigF.tars
// Package configf comment
package configf

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"

	"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/endpoint"
	"github.com/TarsCloud/TarsGo/tars/util/tools"
)

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

type ConfigServant interface {
	ListConfig(app string, server string, vf *[]string) (ret int32, err error)
	LoadConfig(app string, server string, filename string, config *string) (ret int32, err error)
	LoadConfigByHost(appServerName string, filename string, host string, config *string) (ret int32, err error)
	CheckConfig(appServerName string, filename string, host string, result *string) (ret int32, err error)
	ListConfigByInfo(configInfo *ConfigInfo, vf *[]string) (ret int32, err error)
	LoadConfigByInfo(configInfo *ConfigInfo, config *string) (ret int32, err error)
	CheckConfigByInfo(configInfo *ConfigInfo, result *string) (ret int32, err error)
	ListAllConfigByInfo(configInfo *GetConfigListInfo, vf *[]string) (ret int32, err error)
}

type ConfigServantWithContext interface {
	ListConfig(tarsCtx context.Context, app string, server string, vf *[]string) (ret int32, err error)
	LoadConfig(tarsCtx context.Context, app string, server string, filename string, config *string) (ret int32, err error)
	LoadConfigByHost(tarsCtx context.Context, appServerName string, filename string, host string, config *string) (ret int32, err error)
	CheckConfig(tarsCtx context.Context, appServerName string, filename string, host string, result *string) (ret int32, err error)
	ListConfigByInfo(tarsCtx context.Context, configInfo *ConfigInfo, vf *[]string) (ret int32, err error)
	LoadConfigByInfo(tarsCtx context.Context, configInfo *ConfigInfo, config *string) (ret int32, err error)
	CheckConfigByInfo(tarsCtx context.Context, configInfo *ConfigInfo, result *string) (ret int32, err error)
	ListAllConfigByInfo(tarsCtx context.Context, configInfo *GetConfigListInfo, vf *[]string) (ret int32, err error)
}

// Config struct
type Config struct {
	servant model.Servant
}

// NewConfig creates a new Config servant.
func NewConfig() *Config {
	return new(Config)
}

// SetServant sets servant for the service.
func (obj *Config) SetServant(servant model.Servant) {
	obj.servant = servant
}

// TarsSetTimeout sets the timeout for the servant which is in ms.
func (obj *Config) TarsSetTimeout(timeout int) {
	obj.servant.TarsSetTimeout(timeout)
}

// TarsSetProtocol sets the protocol for the servant.
func (obj *Config) TarsSetProtocol(p model.Protocol) {
	obj.servant.TarsSetProtocol(p)
}

// Endpoints returns all active endpoint.Endpoint
func (obj *Config) Endpoints() []*endpoint.Endpoint {
	return obj.servant.Endpoints()
}

// ListConfig is the proxy function for the method defined in the tars file, with the context
func (obj *Config) ListConfig(app string, server string, vf *[]string, opts ...map[string]string) (int32, error) {
	return obj.ListConfigWithContext(context.Background(), app, server, vf, opts...)
}

// ListConfigWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) ListConfigWithContext(tarsCtx context.Context, app string, server string, vf *[]string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = buf.WriteString(app, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(server, 2)
	if err != nil {
		return ret, err
	}

	err = buf.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}
	err = buf.WriteInt32(int32(len(*vf)), 0)
	if err != nil {
		return ret, err
	}
	for _, v := range *vf {
		err = buf.WriteString(v, 0)
		if err != nil {
			return ret, err
		}
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 0, "ListConfig", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}
	readBuf := codec.NewReader(tools.Int8ToByte(tarsResp.SBuffer))
	err = readBuf.ReadInt32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = readBuf.SkipToNoCheck(3, true)
	if err != nil {
		return ret, err
	}
	if ty == codec.LIST {
		err = readBuf.ReadInt32(&length, 0, true)
		if err != nil {
			return ret, err
		}
		*vf = make([]string, length)
		for i0, e0 := int32(0), length; i0 < e0; i0++ {
			err = readBuf.ReadString(&(*vf)[i0], 0, true)
			if err != nil {
				return ret, err
			}
		}
	} else if ty == codec.SimpleList {
		err = fmt.Errorf("not support SimpleList type")
		if err != nil {
			return ret, err
		}
	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}
	}

	if len(opts) == 1 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
	} else if len(opts) == 2 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
		for k := range statusMap {
			delete(statusMap, k)
		}
		for k, v := range tarsResp.Status {
			statusMap[k] = v
		}
	}

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

// ListConfigOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) ListConfigOneWayWithContext(tarsCtx context.Context, app string, server string, vf *[]string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = buf.WriteString(app, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(server, 2)
	if err != nil {
		return ret, err
	}

	err = buf.WriteHead(codec.LIST, 3)
	if err != nil {
		return ret, err
	}
	err = buf.WriteInt32(int32(len(*vf)), 0)
	if err != nil {
		return ret, err
	}
	for _, v := range *vf {
		err = buf.WriteString(v, 0)
		if err != nil {
			return ret, err
		}
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 1, "ListConfig", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}

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

// LoadConfig is the proxy function for the method defined in the tars file, with the context
func (obj *Config) LoadConfig(app string, server string, filename string, config *string, opts ...map[string]string) (int32, error) {
	return obj.LoadConfigWithContext(context.Background(), app, server, filename, config, opts...)
}

// LoadConfigWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) LoadConfigWithContext(tarsCtx context.Context, app string, server string, filename string, config *string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = buf.WriteString(app, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(server, 2)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(filename, 3)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(*config, 4)
	if err != nil {
		return ret, err
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 0, "loadConfig", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}
	readBuf := codec.NewReader(tools.Int8ToByte(tarsResp.SBuffer))
	err = readBuf.ReadInt32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	err = readBuf.ReadString(&(*config), 4, true)
	if err != nil {
		return ret, err
	}

	if len(opts) == 1 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
	} else if len(opts) == 2 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
		for k := range statusMap {
			delete(statusMap, k)
		}
		for k, v := range tarsResp.Status {
			statusMap[k] = v
		}
	}

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

// LoadConfigOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) LoadConfigOneWayWithContext(tarsCtx context.Context, app string, server string, filename string, config *string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = buf.WriteString(app, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(server, 2)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(filename, 3)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(*config, 4)
	if err != nil {
		return ret, err
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 1, "loadConfig", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}

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

// LoadConfigByHost is the proxy function for the method defined in the tars file, with the context
func (obj *Config) LoadConfigByHost(appServerName string, filename string, host string, config *string, opts ...map[string]string) (int32, error) {
	return obj.LoadConfigByHostWithContext(context.Background(), appServerName, filename, host, config, opts...)
}

// LoadConfigByHostWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) LoadConfigByHostWithContext(tarsCtx context.Context, appServerName string, filename string, host string, config *string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = buf.WriteString(appServerName, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(filename, 2)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(host, 3)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(*config, 4)
	if err != nil {
		return ret, err
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 0, "loadConfigByHost", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}
	readBuf := codec.NewReader(tools.Int8ToByte(tarsResp.SBuffer))
	err = readBuf.ReadInt32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	err = readBuf.ReadString(&(*config), 4, true)
	if err != nil {
		return ret, err
	}

	if len(opts) == 1 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
	} else if len(opts) == 2 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
		for k := range statusMap {
			delete(statusMap, k)
		}
		for k, v := range tarsResp.Status {
			statusMap[k] = v
		}
	}

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

// LoadConfigByHostOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) LoadConfigByHostOneWayWithContext(tarsCtx context.Context, appServerName string, filename string, host string, config *string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = buf.WriteString(appServerName, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(filename, 2)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(host, 3)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(*config, 4)
	if err != nil {
		return ret, err
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 1, "loadConfigByHost", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}

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

// CheckConfig is the proxy function for the method defined in the tars file, with the context
func (obj *Config) CheckConfig(appServerName string, filename string, host string, result *string, opts ...map[string]string) (int32, error) {
	return obj.CheckConfigWithContext(context.Background(), appServerName, filename, host, result, opts...)
}

// CheckConfigWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) CheckConfigWithContext(tarsCtx context.Context, appServerName string, filename string, host string, result *string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = buf.WriteString(appServerName, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(filename, 2)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(host, 3)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(*result, 4)
	if err != nil {
		return ret, err
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 0, "checkConfig", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}
	readBuf := codec.NewReader(tools.Int8ToByte(tarsResp.SBuffer))
	err = readBuf.ReadInt32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	err = readBuf.ReadString(&(*result), 4, true)
	if err != nil {
		return ret, err
	}

	if len(opts) == 1 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
	} else if len(opts) == 2 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
		for k := range statusMap {
			delete(statusMap, k)
		}
		for k, v := range tarsResp.Status {
			statusMap[k] = v
		}
	}

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

// CheckConfigOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) CheckConfigOneWayWithContext(tarsCtx context.Context, appServerName string, filename string, host string, result *string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = buf.WriteString(appServerName, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(filename, 2)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(host, 3)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(*result, 4)
	if err != nil {
		return ret, err
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 1, "checkConfig", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}

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

// ListConfigByInfo is the proxy function for the method defined in the tars file, with the context
func (obj *Config) ListConfigByInfo(configInfo *ConfigInfo, vf *[]string, opts ...map[string]string) (int32, error) {
	return obj.ListConfigByInfoWithContext(context.Background(), configInfo, vf, opts...)
}

// ListConfigByInfoWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) ListConfigByInfoWithContext(tarsCtx context.Context, configInfo *ConfigInfo, vf *[]string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = configInfo.WriteBlock(buf, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}
	err = buf.WriteInt32(int32(len(*vf)), 0)
	if err != nil {
		return ret, err
	}
	for _, v := range *vf {
		err = buf.WriteString(v, 0)
		if err != nil {
			return ret, err
		}
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 0, "ListConfigByInfo", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}
	readBuf := codec.NewReader(tools.Int8ToByte(tarsResp.SBuffer))
	err = readBuf.ReadInt32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = readBuf.SkipToNoCheck(2, true)
	if err != nil {
		return ret, err
	}
	if ty == codec.LIST {
		err = readBuf.ReadInt32(&length, 0, true)
		if err != nil {
			return ret, err
		}
		*vf = make([]string, length)
		for i1, e1 := int32(0), length; i1 < e1; i1++ {
			err = readBuf.ReadString(&(*vf)[i1], 0, true)
			if err != nil {
				return ret, err
			}
		}
	} else if ty == codec.SimpleList {
		err = fmt.Errorf("not support SimpleList type")
		if err != nil {
			return ret, err
		}
	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}
	}

	if len(opts) == 1 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
	} else if len(opts) == 2 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
		for k := range statusMap {
			delete(statusMap, k)
		}
		for k, v := range tarsResp.Status {
			statusMap[k] = v
		}
	}

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

// ListConfigByInfoOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) ListConfigByInfoOneWayWithContext(tarsCtx context.Context, configInfo *ConfigInfo, vf *[]string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = configInfo.WriteBlock(buf, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}
	err = buf.WriteInt32(int32(len(*vf)), 0)
	if err != nil {
		return ret, err
	}
	for _, v := range *vf {
		err = buf.WriteString(v, 0)
		if err != nil {
			return ret, err
		}
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 1, "ListConfigByInfo", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}

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

// LoadConfigByInfo is the proxy function for the method defined in the tars file, with the context
func (obj *Config) LoadConfigByInfo(configInfo *ConfigInfo, config *string, opts ...map[string]string) (int32, error) {
	return obj.LoadConfigByInfoWithContext(context.Background(), configInfo, config, opts...)
}

// LoadConfigByInfoWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) LoadConfigByInfoWithContext(tarsCtx context.Context, configInfo *ConfigInfo, config *string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = configInfo.WriteBlock(buf, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(*config, 2)
	if err != nil {
		return ret, err
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 0, "loadConfigByInfo", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}
	readBuf := codec.NewReader(tools.Int8ToByte(tarsResp.SBuffer))
	err = readBuf.ReadInt32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	err = readBuf.ReadString(&(*config), 2, true)
	if err != nil {
		return ret, err
	}

	if len(opts) == 1 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
	} else if len(opts) == 2 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
		for k := range statusMap {
			delete(statusMap, k)
		}
		for k, v := range tarsResp.Status {
			statusMap[k] = v
		}
	}

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

// LoadConfigByInfoOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) LoadConfigByInfoOneWayWithContext(tarsCtx context.Context, configInfo *ConfigInfo, config *string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = configInfo.WriteBlock(buf, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(*config, 2)
	if err != nil {
		return ret, err
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 1, "loadConfigByInfo", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}

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

// CheckConfigByInfo is the proxy function for the method defined in the tars file, with the context
func (obj *Config) CheckConfigByInfo(configInfo *ConfigInfo, result *string, opts ...map[string]string) (int32, error) {
	return obj.CheckConfigByInfoWithContext(context.Background(), configInfo, result, opts...)
}

// CheckConfigByInfoWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) CheckConfigByInfoWithContext(tarsCtx context.Context, configInfo *ConfigInfo, result *string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = configInfo.WriteBlock(buf, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(*result, 2)
	if err != nil {
		return ret, err
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 0, "checkConfigByInfo", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}
	readBuf := codec.NewReader(tools.Int8ToByte(tarsResp.SBuffer))
	err = readBuf.ReadInt32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	err = readBuf.ReadString(&(*result), 2, true)
	if err != nil {
		return ret, err
	}

	if len(opts) == 1 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
	} else if len(opts) == 2 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
		for k := range statusMap {
			delete(statusMap, k)
		}
		for k, v := range tarsResp.Status {
			statusMap[k] = v
		}
	}

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

// CheckConfigByInfoOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) CheckConfigByInfoOneWayWithContext(tarsCtx context.Context, configInfo *ConfigInfo, result *string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = configInfo.WriteBlock(buf, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteString(*result, 2)
	if err != nil {
		return ret, err
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 1, "checkConfigByInfo", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}

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

// ListAllConfigByInfo is the proxy function for the method defined in the tars file, with the context
func (obj *Config) ListAllConfigByInfo(configInfo *GetConfigListInfo, vf *[]string, opts ...map[string]string) (int32, error) {
	return obj.ListAllConfigByInfoWithContext(context.Background(), configInfo, vf, opts...)
}

// ListAllConfigByInfoWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) ListAllConfigByInfoWithContext(tarsCtx context.Context, configInfo *GetConfigListInfo, vf *[]string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = configInfo.WriteBlock(buf, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}
	err = buf.WriteInt32(int32(len(*vf)), 0)
	if err != nil {
		return ret, err
	}
	for _, v := range *vf {
		err = buf.WriteString(v, 0)
		if err != nil {
			return ret, err
		}
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 0, "ListAllConfigByInfo", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}
	readBuf := codec.NewReader(tools.Int8ToByte(tarsResp.SBuffer))
	err = readBuf.ReadInt32(&ret, 0, true)
	if err != nil {
		return ret, err
	}

	_, ty, err = readBuf.SkipToNoCheck(2, true)
	if err != nil {
		return ret, err
	}
	if ty == codec.LIST {
		err = readBuf.ReadInt32(&length, 0, true)
		if err != nil {
			return ret, err
		}
		*vf = make([]string, length)
		for i2, e2 := int32(0), length; i2 < e2; i2++ {
			err = readBuf.ReadString(&(*vf)[i2], 0, true)
			if err != nil {
				return ret, err
			}
		}
	} else if ty == codec.SimpleList {
		err = fmt.Errorf("not support SimpleList type")
		if err != nil {
			return ret, err
		}
	} else {
		err = fmt.Errorf("require vector, but not")
		if err != nil {
			return ret, err
		}
	}

	if len(opts) == 1 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
	} else if len(opts) == 2 {
		for k := range contextMap {
			delete(contextMap, k)
		}
		for k, v := range tarsResp.Context {
			contextMap[k] = v
		}
		for k := range statusMap {
			delete(statusMap, k)
		}
		for k, v := range tarsResp.Status {
			statusMap[k] = v
		}
	}

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

// ListAllConfigByInfoOneWayWithContext is the proxy function for the method defined in the tars file, with the context
func (obj *Config) ListAllConfigByInfoOneWayWithContext(tarsCtx context.Context, configInfo *GetConfigListInfo, vf *[]string, opts ...map[string]string) (ret int32, err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	buf := codec.NewBuffer()
	err = configInfo.WriteBlock(buf, 1)
	if err != nil {
		return ret, err
	}

	err = buf.WriteHead(codec.LIST, 2)
	if err != nil {
		return ret, err
	}
	err = buf.WriteInt32(int32(len(*vf)), 0)
	if err != nil {
		return ret, err
	}
	for _, v := range *vf {
		err = buf.WriteString(v, 0)
		if err != nil {
			return ret, err
		}
	}

	var statusMap map[string]string
	var contextMap map[string]string
	if len(opts) == 1 {
		contextMap = opts[0]
	} else if len(opts) == 2 {
		contextMap = opts[0]
		statusMap = opts[1]
	}

	tarsResp := new(requestf.ResponsePacket)
	err = obj.servant.TarsInvoke(tarsCtx, 1, "ListAllConfigByInfo", buf.ToBytes(), statusMap, contextMap, tarsResp)
	if err != nil {
		return ret, err
	}

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

// 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 *Config) Dispatch(tarsCtx context.Context, val interface{}, tarsReq *requestf.RequestPacket, tarsResp *requestf.ResponsePacket, withContext bool) (err error) {
	var (
		length int32
		have   bool
		ty     byte
	)
	readBuf := codec.NewReader(tools.Int8ToByte(tarsReq.SBuffer))
	buf := codec.NewBuffer()
	switch tarsReq.SFuncName {
	case "ListConfig":
		var app string
		var server string
		var vf []string
		vf = make([]string, 0)
		if tarsReq.IVersion == basef.TARSVERSION {
			err = readBuf.ReadString(&app, 1, true)
			if err != nil {
				return err
			}
			err = readBuf.ReadString(&server, 2, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			reqTup := tup.NewUniAttribute()
			reqTup.Decode(readBuf)

			var tupBuffer []byte

			reqTup.GetBuffer("app", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = readBuf.ReadString(&app, 0, true)
			if err != nil {
				return err
			}

			reqTup.GetBuffer("server", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = readBuf.ReadString(&server, 0, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			var jsonData map[string]interface{}
			decoder := json.NewDecoder(bytes.NewReader(readBuf.ToBytes()))
			decoder.UseNumber()
			err = decoder.Decode(&jsonData)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				jsonStr, _ := json.Marshal(jsonData["app"])
				if err = json.Unmarshal(jsonStr, &app); err != nil {
					return err
				}
			}
			{
				jsonStr, _ := json.Marshal(jsonData["server"])
				if err = json.Unmarshal(jsonStr, &server); 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.(ConfigServant)
			funRet, err = imp.ListConfig(app, server, &vf)
		} else {
			imp := val.(ConfigServantWithContext)
			funRet, err = imp.ListConfig(tarsCtx, app, server, &vf)
		}
		if err != nil {
			return err
		}

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

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}
			err = buf.WriteHead(codec.LIST, 3)
			if err != nil {
				return err
			}
			err = buf.WriteInt32(int32(len(vf)), 0)
			if err != nil {
				return err
			}
			for _, v := range vf {
				err = buf.WriteString(v, 0)
				if err != nil {
					return err
				}
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			rspTup := tup.NewUniAttribute()

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}

			rspTup.PutBuffer("", buf.ToBytes())
			rspTup.PutBuffer("tars_ret", buf.ToBytes())

			buf.Reset()
			err = buf.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}
			err = buf.WriteInt32(int32(len(vf)), 0)
			if err != nil {
				return err
			}
			for _, v := range vf {
				err = buf.WriteString(v, 0)
				if err != nil {
					return err
				}
			}
			rspTup.PutBuffer("vf", buf.ToBytes())

			buf.Reset()
			err = rspTup.Encode(buf)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			rspJson := map[string]interface{}{}
			rspJson["tars_ret"] = funRet
			rspJson["vf"] = vf

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

			buf.Reset()
			err = buf.WriteSliceUint8(rspByte)
			if err != nil {
				return err
			}
		}
	case "loadConfig":
		var app string
		var server string
		var filename string
		var config string
		if tarsReq.IVersion == basef.TARSVERSION {
			err = readBuf.ReadString(&app, 1, true)
			if err != nil {
				return err
			}
			err = readBuf.ReadString(&server, 2, true)
			if err != nil {
				return err
			}
			err = readBuf.ReadString(&filename, 3, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			reqTup := tup.NewUniAttribute()
			reqTup.Decode(readBuf)

			var tupBuffer []byte

			reqTup.GetBuffer("app", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = readBuf.ReadString(&app, 0, true)
			if err != nil {
				return err
			}

			reqTup.GetBuffer("server", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = readBuf.ReadString(&server, 0, true)
			if err != nil {
				return err
			}

			reqTup.GetBuffer("filename", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = readBuf.ReadString(&filename, 0, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			var jsonData map[string]interface{}
			decoder := json.NewDecoder(bytes.NewReader(readBuf.ToBytes()))
			decoder.UseNumber()
			err = decoder.Decode(&jsonData)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				jsonStr, _ := json.Marshal(jsonData["app"])
				if err = json.Unmarshal(jsonStr, &app); err != nil {
					return err
				}
			}
			{
				jsonStr, _ := json.Marshal(jsonData["server"])
				if err = json.Unmarshal(jsonStr, &server); err != nil {
					return err
				}
			}
			{
				jsonStr, _ := json.Marshal(jsonData["filename"])
				if err = json.Unmarshal(jsonStr, &filename); 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.(ConfigServant)
			funRet, err = imp.LoadConfig(app, server, filename, &config)
		} else {
			imp := val.(ConfigServantWithContext)
			funRet, err = imp.LoadConfig(tarsCtx, app, server, filename, &config)
		}
		if err != nil {
			return err
		}

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

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}
			err = buf.WriteString(config, 4)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			rspTup := tup.NewUniAttribute()

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}

			rspTup.PutBuffer("", buf.ToBytes())
			rspTup.PutBuffer("tars_ret", buf.ToBytes())

			buf.Reset()
			err = buf.WriteString(config, 0)
			if err != nil {
				return err
			}
			rspTup.PutBuffer("config", buf.ToBytes())

			buf.Reset()
			err = rspTup.Encode(buf)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			rspJson := map[string]interface{}{}
			rspJson["tars_ret"] = funRet
			rspJson["config"] = config

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

			buf.Reset()
			err = buf.WriteSliceUint8(rspByte)
			if err != nil {
				return err
			}
		}
	case "loadConfigByHost":
		var appServerName string
		var filename string
		var host string
		var config string
		if tarsReq.IVersion == basef.TARSVERSION {
			err = readBuf.ReadString(&appServerName, 1, true)
			if err != nil {
				return err
			}
			err = readBuf.ReadString(&filename, 2, true)
			if err != nil {
				return err
			}
			err = readBuf.ReadString(&host, 3, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			reqTup := tup.NewUniAttribute()
			reqTup.Decode(readBuf)

			var tupBuffer []byte

			reqTup.GetBuffer("appServerName", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = readBuf.ReadString(&appServerName, 0, true)
			if err != nil {
				return err
			}

			reqTup.GetBuffer("filename", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = readBuf.ReadString(&filename, 0, true)
			if err != nil {
				return err
			}

			reqTup.GetBuffer("host", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = readBuf.ReadString(&host, 0, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			var jsonData map[string]interface{}
			decoder := json.NewDecoder(bytes.NewReader(readBuf.ToBytes()))
			decoder.UseNumber()
			err = decoder.Decode(&jsonData)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				jsonStr, _ := json.Marshal(jsonData["appServerName"])
				if err = json.Unmarshal(jsonStr, &appServerName); err != nil {
					return err
				}
			}
			{
				jsonStr, _ := json.Marshal(jsonData["filename"])
				if err = json.Unmarshal(jsonStr, &filename); err != nil {
					return err
				}
			}
			{
				jsonStr, _ := json.Marshal(jsonData["host"])
				if err = json.Unmarshal(jsonStr, &host); 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.(ConfigServant)
			funRet, err = imp.LoadConfigByHost(appServerName, filename, host, &config)
		} else {
			imp := val.(ConfigServantWithContext)
			funRet, err = imp.LoadConfigByHost(tarsCtx, appServerName, filename, host, &config)
		}
		if err != nil {
			return err
		}

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

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}
			err = buf.WriteString(config, 4)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			rspTup := tup.NewUniAttribute()

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}

			rspTup.PutBuffer("", buf.ToBytes())
			rspTup.PutBuffer("tars_ret", buf.ToBytes())

			buf.Reset()
			err = buf.WriteString(config, 0)
			if err != nil {
				return err
			}
			rspTup.PutBuffer("config", buf.ToBytes())

			buf.Reset()
			err = rspTup.Encode(buf)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			rspJson := map[string]interface{}{}
			rspJson["tars_ret"] = funRet
			rspJson["config"] = config

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

			buf.Reset()
			err = buf.WriteSliceUint8(rspByte)
			if err != nil {
				return err
			}
		}
	case "checkConfig":
		var appServerName string
		var filename string
		var host string
		var result string
		if tarsReq.IVersion == basef.TARSVERSION {
			err = readBuf.ReadString(&appServerName, 1, true)
			if err != nil {
				return err
			}
			err = readBuf.ReadString(&filename, 2, true)
			if err != nil {
				return err
			}
			err = readBuf.ReadString(&host, 3, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			reqTup := tup.NewUniAttribute()
			reqTup.Decode(readBuf)

			var tupBuffer []byte

			reqTup.GetBuffer("appServerName", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = readBuf.ReadString(&appServerName, 0, true)
			if err != nil {
				return err
			}

			reqTup.GetBuffer("filename", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = readBuf.ReadString(&filename, 0, true)
			if err != nil {
				return err
			}

			reqTup.GetBuffer("host", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = readBuf.ReadString(&host, 0, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			var jsonData map[string]interface{}
			decoder := json.NewDecoder(bytes.NewReader(readBuf.ToBytes()))
			decoder.UseNumber()
			err = decoder.Decode(&jsonData)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				jsonStr, _ := json.Marshal(jsonData["appServerName"])
				if err = json.Unmarshal(jsonStr, &appServerName); err != nil {
					return err
				}
			}
			{
				jsonStr, _ := json.Marshal(jsonData["filename"])
				if err = json.Unmarshal(jsonStr, &filename); err != nil {
					return err
				}
			}
			{
				jsonStr, _ := json.Marshal(jsonData["host"])
				if err = json.Unmarshal(jsonStr, &host); 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.(ConfigServant)
			funRet, err = imp.CheckConfig(appServerName, filename, host, &result)
		} else {
			imp := val.(ConfigServantWithContext)
			funRet, err = imp.CheckConfig(tarsCtx, appServerName, filename, host, &result)
		}
		if err != nil {
			return err
		}

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

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}
			err = buf.WriteString(result, 4)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			rspTup := tup.NewUniAttribute()

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}

			rspTup.PutBuffer("", buf.ToBytes())
			rspTup.PutBuffer("tars_ret", buf.ToBytes())

			buf.Reset()
			err = buf.WriteString(result, 0)
			if err != nil {
				return err
			}
			rspTup.PutBuffer("result", buf.ToBytes())

			buf.Reset()
			err = rspTup.Encode(buf)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			rspJson := map[string]interface{}{}
			rspJson["tars_ret"] = funRet
			rspJson["result"] = result

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

			buf.Reset()
			err = buf.WriteSliceUint8(rspByte)
			if err != nil {
				return err
			}
		}
	case "ListConfigByInfo":
		var configInfo ConfigInfo
		var vf []string
		vf = make([]string, 0)
		if tarsReq.IVersion == basef.TARSVERSION {
			err = configInfo.ReadBlock(readBuf, 1, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			reqTup := tup.NewUniAttribute()
			reqTup.Decode(readBuf)

			var tupBuffer []byte

			reqTup.GetBuffer("configInfo", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = configInfo.ReadBlock(readBuf, 0, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			var jsonData map[string]interface{}
			decoder := json.NewDecoder(bytes.NewReader(readBuf.ToBytes()))
			decoder.UseNumber()
			err = decoder.Decode(&jsonData)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				jsonStr, _ := json.Marshal(jsonData["configInfo"])
				configInfo.ResetDefault()
				if err = json.Unmarshal(jsonStr, &configInfo); 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.(ConfigServant)
			funRet, err = imp.ListConfigByInfo(&configInfo, &vf)
		} else {
			imp := val.(ConfigServantWithContext)
			funRet, err = imp.ListConfigByInfo(tarsCtx, &configInfo, &vf)
		}
		if err != nil {
			return err
		}

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

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}
			err = buf.WriteHead(codec.LIST, 2)
			if err != nil {
				return err
			}
			err = buf.WriteInt32(int32(len(vf)), 0)
			if err != nil {
				return err
			}
			for _, v := range vf {
				err = buf.WriteString(v, 0)
				if err != nil {
					return err
				}
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			rspTup := tup.NewUniAttribute()

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}

			rspTup.PutBuffer("", buf.ToBytes())
			rspTup.PutBuffer("tars_ret", buf.ToBytes())

			buf.Reset()
			err = buf.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}
			err = buf.WriteInt32(int32(len(vf)), 0)
			if err != nil {
				return err
			}
			for _, v := range vf {
				err = buf.WriteString(v, 0)
				if err != nil {
					return err
				}
			}
			rspTup.PutBuffer("vf", buf.ToBytes())

			buf.Reset()
			err = rspTup.Encode(buf)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			rspJson := map[string]interface{}{}
			rspJson["tars_ret"] = funRet
			rspJson["vf"] = vf

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

			buf.Reset()
			err = buf.WriteSliceUint8(rspByte)
			if err != nil {
				return err
			}
		}
	case "loadConfigByInfo":
		var configInfo ConfigInfo
		var config string
		if tarsReq.IVersion == basef.TARSVERSION {
			err = configInfo.ReadBlock(readBuf, 1, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			reqTup := tup.NewUniAttribute()
			reqTup.Decode(readBuf)

			var tupBuffer []byte

			reqTup.GetBuffer("configInfo", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = configInfo.ReadBlock(readBuf, 0, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			var jsonData map[string]interface{}
			decoder := json.NewDecoder(bytes.NewReader(readBuf.ToBytes()))
			decoder.UseNumber()
			err = decoder.Decode(&jsonData)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				jsonStr, _ := json.Marshal(jsonData["configInfo"])
				configInfo.ResetDefault()
				if err = json.Unmarshal(jsonStr, &configInfo); 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.(ConfigServant)
			funRet, err = imp.LoadConfigByInfo(&configInfo, &config)
		} else {
			imp := val.(ConfigServantWithContext)
			funRet, err = imp.LoadConfigByInfo(tarsCtx, &configInfo, &config)
		}
		if err != nil {
			return err
		}

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

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}
			err = buf.WriteString(config, 2)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			rspTup := tup.NewUniAttribute()

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}

			rspTup.PutBuffer("", buf.ToBytes())
			rspTup.PutBuffer("tars_ret", buf.ToBytes())

			buf.Reset()
			err = buf.WriteString(config, 0)
			if err != nil {
				return err
			}
			rspTup.PutBuffer("config", buf.ToBytes())

			buf.Reset()
			err = rspTup.Encode(buf)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			rspJson := map[string]interface{}{}
			rspJson["tars_ret"] = funRet
			rspJson["config"] = config

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

			buf.Reset()
			err = buf.WriteSliceUint8(rspByte)
			if err != nil {
				return err
			}
		}
	case "checkConfigByInfo":
		var configInfo ConfigInfo
		var result string
		if tarsReq.IVersion == basef.TARSVERSION {
			err = configInfo.ReadBlock(readBuf, 1, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			reqTup := tup.NewUniAttribute()
			reqTup.Decode(readBuf)

			var tupBuffer []byte

			reqTup.GetBuffer("configInfo", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = configInfo.ReadBlock(readBuf, 0, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			var jsonData map[string]interface{}
			decoder := json.NewDecoder(bytes.NewReader(readBuf.ToBytes()))
			decoder.UseNumber()
			err = decoder.Decode(&jsonData)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				jsonStr, _ := json.Marshal(jsonData["configInfo"])
				configInfo.ResetDefault()
				if err = json.Unmarshal(jsonStr, &configInfo); 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.(ConfigServant)
			funRet, err = imp.CheckConfigByInfo(&configInfo, &result)
		} else {
			imp := val.(ConfigServantWithContext)
			funRet, err = imp.CheckConfigByInfo(tarsCtx, &configInfo, &result)
		}
		if err != nil {
			return err
		}

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

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}
			err = buf.WriteString(result, 2)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			rspTup := tup.NewUniAttribute()

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}

			rspTup.PutBuffer("", buf.ToBytes())
			rspTup.PutBuffer("tars_ret", buf.ToBytes())

			buf.Reset()
			err = buf.WriteString(result, 0)
			if err != nil {
				return err
			}
			rspTup.PutBuffer("result", buf.ToBytes())

			buf.Reset()
			err = rspTup.Encode(buf)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			rspJson := map[string]interface{}{}
			rspJson["tars_ret"] = funRet
			rspJson["result"] = result

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

			buf.Reset()
			err = buf.WriteSliceUint8(rspByte)
			if err != nil {
				return err
			}
		}
	case "ListAllConfigByInfo":
		var configInfo GetConfigListInfo
		var vf []string
		vf = make([]string, 0)
		if tarsReq.IVersion == basef.TARSVERSION {
			err = configInfo.ReadBlock(readBuf, 1, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			reqTup := tup.NewUniAttribute()
			reqTup.Decode(readBuf)

			var tupBuffer []byte

			reqTup.GetBuffer("configInfo", &tupBuffer)
			readBuf.Reset(tupBuffer)
			err = configInfo.ReadBlock(readBuf, 0, true)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			var jsonData map[string]interface{}
			decoder := json.NewDecoder(bytes.NewReader(readBuf.ToBytes()))
			decoder.UseNumber()
			err = decoder.Decode(&jsonData)
			if err != nil {
				return fmt.Errorf("decode reqpacket failed, error: %+v", err)
			}
			{
				jsonStr, _ := json.Marshal(jsonData["configInfo"])
				configInfo.ResetDefault()
				if err = json.Unmarshal(jsonStr, &configInfo); 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.(ConfigServant)
			funRet, err = imp.ListAllConfigByInfo(&configInfo, &vf)
		} else {
			imp := val.(ConfigServantWithContext)
			funRet, err = imp.ListAllConfigByInfo(tarsCtx, &configInfo, &vf)
		}
		if err != nil {
			return err
		}

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

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}
			err = buf.WriteHead(codec.LIST, 2)
			if err != nil {
				return err
			}
			err = buf.WriteInt32(int32(len(vf)), 0)
			if err != nil {
				return err
			}
			for _, v := range vf {
				err = buf.WriteString(v, 0)
				if err != nil {
					return err
				}
			}
		} else if tarsReq.IVersion == basef.TUPVERSION {
			rspTup := tup.NewUniAttribute()

			err = buf.WriteInt32(funRet, 0)
			if err != nil {
				return err
			}

			rspTup.PutBuffer("", buf.ToBytes())
			rspTup.PutBuffer("tars_ret", buf.ToBytes())

			buf.Reset()
			err = buf.WriteHead(codec.LIST, 0)
			if err != nil {
				return err
			}
			err = buf.WriteInt32(int32(len(vf)), 0)
			if err != nil {
				return err
			}
			for _, v := range vf {
				err = buf.WriteString(v, 0)
				if err != nil {
					return err
				}
			}
			rspTup.PutBuffer("vf", buf.ToBytes())

			buf.Reset()
			err = rspTup.Encode(buf)
			if err != nil {
				return err
			}
		} else if tarsReq.IVersion == basef.JSONVERSION {
			rspJson := map[string]interface{}{}
			rspJson["tars_ret"] = funRet
			rspJson["vf"] = vf

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

			buf.Reset()
			err = buf.WriteSliceUint8(rspByte)
			if err != nil {
				return err
			}
		}

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

	_ = readBuf
	_ = buf
	_ = length
	_ = have
	_ = ty
	return nil
}