TarsCpp/unit-test/server/Hello.h

// **********************************************************************
// This file was generated by a TARS parser!
// TARS version 3.0.6.
// **********************************************************************

#ifndef __HELLO_H_
#define __HELLO_H_

#include <map>
#include <string>
#include <vector>
#include "tup/Tars.h"
#include "tup/TarsJson.h"
using namespace std;
#include "servant/ServantProxy.h"
#include "servant/Servant.h"
#include "promise/promise.h"
#include "servant/Application.h"


namespace Test
{
    enum EN_KEY
    {
        KEY1 = 1,
        KEY2 = 2,
    };
    inline string etos(const EN_KEY & e)
    {
        switch(e)
        {
            case KEY1: return "KEY1";
            case KEY2: return "KEY2";
            default: return "";
        }
    }
    inline int stoe(const string & s, EN_KEY & e)
    {
        if(s == "KEY1")  { e=KEY1; return 0;}
        if(s == "KEY2")  { e=KEY2; return 0;}

        return -1;
    }

    struct JsonKey : public tars::TarsStructBase
    {
    public:
        static string className()
        {
            return "Test.JsonKey";
        }
        static string MD5()
        {
            return "7b010a6336d210a506b1eb4bf4c1e014";
        }
        JsonKey()
        {
            resetDefautlt();
        }
        void resetDefautlt()
        {
            i = 0;
        }
        template<typename WriterT>
        void writeTo(tars::TarsOutputStream<WriterT>& _os) const
        {
            if (i != 0)
            {
                _os.write(i, 0);
            }
        }
        template<typename ReaderT>
        void readFrom(tars::TarsInputStream<ReaderT>& _is)
        {
            resetDefautlt();
            _is.read(i, 0, false);
        }
        tars::JsonValueObjPtr writeToJson() const
        {
            tars::JsonValueObjPtr p = new tars::JsonValueObj();
            p->value["i"] = tars::JsonOutput::writeJson(i);
            return p;
        }
        string writeToJsonString() const
        {
            return tars::TC_Json::writeValue(writeToJson());
        }
        void readFromJson(const tars::JsonValuePtr & p, bool isRequire = true)
        {
            resetDefautlt();
            if(NULL == p.get() || p->getType() != tars::eJsonTypeObj)
            {
                char s[128];
                snprintf(s, sizeof(s), "read 'struct' type mismatch, get type: %d.", (p.get() ? p->getType() : 0));
                throw tars::TC_Json_Exception(s);
            }
            tars::JsonValueObjPtr pObj=tars::JsonValueObjPtr::dynamicCast(p);
            tars::JsonInput::readJson(i,pObj->value["i"], false);
        }
        void readFromJsonString(const string & str)
        {
            readFromJson(tars::TC_Json::getValue(str));
        }
        ostream& display(ostream& _os, int _level=0) const
        {
            tars::TarsDisplayer _ds(_os, _level);
            _ds.display(i,"i");
            return _os;
        }
        ostream& displaySimple(ostream& _os, int _level=0) const
        {
            tars::TarsDisplayer _ds(_os, _level);
            _ds.displaySimple(i, false);
            return _os;
        }
    public:
        tars::Int32 i;
    };
    inline bool operator==(const JsonKey&l, const JsonKey&r)
    {
        return l.i == r.i;
    }
    inline bool operator!=(const JsonKey&l, const JsonKey&r)
    {
        return !(l == r);
    }
    inline ostream& operator<<(ostream & os,const JsonKey&r)
    {
        os << r.writeToJsonString();
        return os;
    }
    inline istream& operator>>(istream& is,JsonKey&l)
    {
        std::istreambuf_iterator<char> eos;
        std::string s(std::istreambuf_iterator<char>(is), eos);
        l.readFromJsonString(s);
        return is;
    }
    inline bool operator<(const JsonKey&l, const JsonKey&r)
    {
        if(l.i != r.i)  return (l.i < r.i);
        return false;
    }
    inline bool operator<=(const JsonKey&l, const JsonKey&r)
    {
        return !(r < l);
    }
    inline bool operator>(const JsonKey&l, const JsonKey&r)
    {
        return r < l;
    }
    inline bool operator>=(const JsonKey&l, const JsonKey&r)
    {
        return !(l < r);
    }

    struct JsonData : public tars::TarsStructBase
    {
    public:
        static string className()
        {
            return "Test.JsonData";
        }
        static string MD5()
        {
            return "7e2b4e48c7c69de6efedb26120c23c90";
        }
        JsonData()
        {
            resetDefautlt();
        }
        void resetDefautlt()
        {
            c = 0;
            s = 0;
            i = 0;
            l = 0;
            f = 0;
            d = 0;
            uc = 0;
            us = 0;
            ui = 0;
            b = true;
            k = Test::KEY1;
            ss = "";
            data.clear();
            v.clear();
            im.clear();
            bm.clear();
            fm.clear();
            bv.clear();
            iv.clear();
            dv.clear();
        }
        template<typename WriterT>
        void writeTo(tars::TarsOutputStream<WriterT>& _os) const
        {
            if (c != 0)
            {
                _os.write(c, 0);
            }
            if (s != 0)
            {
                _os.write(s, 1);
            }
            if (i != 0)
            {
                _os.write(i, 2);
            }
            if (l != 0)
            {
                _os.write(l, 3);
            }
            if (f != 0)
            {
                _os.write(f, 4);
            }
            if (d != 0)
            {
                _os.write(d, 5);
            }
            if (uc != 0)
            {
                _os.write(uc, 6);
            }
            if (us != 0)
            {
                _os.write(us, 7);
            }
            if (ui != 0)
            {
                _os.write(ui, 8);
            }
            if (b != true)
            {
                _os.write(b, 9);
            }
            _os.write((tars::Int32)k, 10);
            if (ss != "")
            {
                _os.write(ss, 11);
            }
            if (data.size() > 0)
            {
                _os.write(data, 12);
            }
            if (v.size() > 0)
            {
                _os.write(v, 13);
            }
            if (im.size() > 0)
            {
                _os.write(im, 14);
            }
            if (bm.size() > 0)
            {
                _os.write(bm, 15);
            }
            if (fm.size() > 0)
            {
                _os.write(fm, 16);
            }
            if (bv.size() > 0)
            {
                _os.write(bv, 17);
            }
            if (iv.size() > 0)
            {
                _os.write(iv, 18);
            }
            if (dv.size() > 0)
            {
                _os.write(dv, 19);
            }
        }
        template<typename ReaderT>
        void readFrom(tars::TarsInputStream<ReaderT>& _is)
        {
            resetDefautlt();
            _is.read(c, 0, false);
            _is.read(s, 1, false);
            _is.read(i, 2, false);
            _is.read(l, 3, false);
            _is.read(f, 4, false);
            _is.read(d, 5, false);
            _is.read(uc, 6, false);
            _is.read(us, 7, false);
            _is.read(ui, 8, false);
            _is.read(b, 9, false);
            tars::Int32 eTemp10 = Test::KEY1;
            _is.read(eTemp10, 10, false);
            k = (Test::EN_KEY)eTemp10;
            _is.read(ss, 11, false);
            _is.read(data, 12, false);
            _is.read(v, 13, false);
            _is.read(im, 14, false);
            _is.read(bm, 15, false);
            _is.read(fm, 16, false);
            _is.read(bv, 17, false);
            _is.read(iv, 18, false);
            _is.read(dv, 19, false);
        }
        tars::JsonValueObjPtr writeToJson() const
        {
            tars::JsonValueObjPtr p = new tars::JsonValueObj();
            p->value["c"] = tars::JsonOutput::writeJson(c);
            p->value["s"] = tars::JsonOutput::writeJson(s);
            p->value["i"] = tars::JsonOutput::writeJson(i);
            p->value["l"] = tars::JsonOutput::writeJson(l);
            p->value["f"] = tars::JsonOutput::writeJson(f);
            p->value["d"] = tars::JsonOutput::writeJson(d);
            p->value["uc"] = tars::JsonOutput::writeJson(uc);
            p->value["us"] = tars::JsonOutput::writeJson(us);
            p->value["ui"] = tars::JsonOutput::writeJson(ui);
            p->value["b"] = tars::JsonOutput::writeJson(b);
            p->value["k"] = tars::JsonOutput::writeJson((tars::Int32)k);
            p->value["ss"] = tars::JsonOutput::writeJson(ss);
            p->value["data"] = tars::JsonOutput::writeJson(data);
            p->value["v"] = tars::JsonOutput::writeJson(v);
            p->value["im"] = tars::JsonOutput::writeJson(im);
            p->value["bm"] = tars::JsonOutput::writeJson(bm);
            p->value["fm"] = tars::JsonOutput::writeJson(fm);
            p->value["bv"] = tars::JsonOutput::writeJson(bv);
            p->value["iv"] = tars::JsonOutput::writeJson(iv);
            p->value["dv"] = tars::JsonOutput::writeJson(dv);
            return p;
        }
        string writeToJsonString() const
        {
            return tars::TC_Json::writeValue(writeToJson());
        }
        void readFromJson(const tars::JsonValuePtr & p, bool isRequire = true)
        {
            resetDefautlt();
            if(NULL == p.get() || p->getType() != tars::eJsonTypeObj)
            {
                char s[128];
                snprintf(s, sizeof(s), "read 'struct' type mismatch, get type: %d.", (p.get() ? p->getType() : 0));
                throw tars::TC_Json_Exception(s);
            }
            tars::JsonValueObjPtr pObj=tars::JsonValueObjPtr::dynamicCast(p);
            tars::JsonInput::readJson(c,pObj->value["c"], false);
            tars::JsonInput::readJson(s,pObj->value["s"], false);
            tars::JsonInput::readJson(i,pObj->value["i"], false);
            tars::JsonInput::readJson(l,pObj->value["l"], false);
            tars::JsonInput::readJson(f,pObj->value["f"], false);
            tars::JsonInput::readJson(d,pObj->value["d"], false);
            tars::JsonInput::readJson(uc,pObj->value["uc"], false);
            tars::JsonInput::readJson(us,pObj->value["us"], false);
            tars::JsonInput::readJson(ui,pObj->value["ui"], false);
            tars::JsonInput::readJson(b,pObj->value["b"], false);
            tars::JsonInput::readJson(k,pObj->value["k"], false);
            tars::JsonInput::readJson(ss,pObj->value["ss"], false);
            tars::JsonInput::readJson(data,pObj->value["data"], false);
            tars::JsonInput::readJson(v,pObj->value["v"], false);
            tars::JsonInput::readJson(im,pObj->value["im"], false);
            tars::JsonInput::readJson(bm,pObj->value["bm"], false);
            tars::JsonInput::readJson(fm,pObj->value["fm"], false);
            tars::JsonInput::readJson(bv,pObj->value["bv"], false);
            tars::JsonInput::readJson(iv,pObj->value["iv"], false);
            tars::JsonInput::readJson(dv,pObj->value["dv"], false);
        }
        void readFromJsonString(const string & str)
        {
            readFromJson(tars::TC_Json::getValue(str));
        }
        ostream& display(ostream& _os, int _level=0) const
        {
            tars::TarsDisplayer _ds(_os, _level);
            _ds.display(c,"c");
            _ds.display(s,"s");
            _ds.display(i,"i");
            _ds.display(l,"l");
            _ds.display(f,"f");
            _ds.display(d,"d");
            _ds.display(uc,"uc");
            _ds.display(us,"us");
            _ds.display(ui,"ui");
            _ds.display(b,"b");
            _ds.display((tars::Int32)k,"k");
            _ds.display(ss,"ss");
            _ds.display(data,"data");
            _ds.display(v,"v");
            _ds.display(im,"im");
            _ds.display(bm,"bm");
            _ds.display(fm,"fm");
            _ds.display(bv,"bv");
            _ds.display(iv,"iv");
            _ds.display(dv,"dv");
            return _os;
        }
        ostream& displaySimple(ostream& _os, int _level=0) const
        {
            tars::TarsDisplayer _ds(_os, _level);
            _ds.displaySimple(c, true);
            _ds.displaySimple(s, true);
            _ds.displaySimple(i, true);
            _ds.displaySimple(l, true);
            _ds.displaySimple(f, true);
            _ds.displaySimple(d, true);
            _ds.displaySimple(uc, true);
            _ds.displaySimple(us, true);
            _ds.displaySimple(ui, true);
            _ds.displaySimple(b, true);
            _ds.displaySimple((tars::Int32)k, true);
            _ds.displaySimple(ss, true);
            _ds.displaySimple(data, true);
            _ds.displaySimple(v, true);
            _ds.displaySimple(im, true);
            _ds.displaySimple(bm, true);
            _ds.displaySimple(fm, true);
            _ds.displaySimple(bv, true);
            _ds.displaySimple(iv, true);
            _ds.displaySimple(dv, false);
            return _os;
        }
    public:
        tars::Char c;
        tars::Short s;
        tars::Int32 i;
        tars::Int64 l;
        tars::Float f;
        tars::Double d;
        tars::UInt8 uc;
        tars::UInt16 us;
        tars::UInt32 ui;
        tars::Bool b;
        Test::EN_KEY k;
        std::string ss;
        map<Test::EN_KEY, std::string> data;
        vector<Test::EN_KEY> v;
        map<tars::Int32, std::string> im;
        map<tars::Bool, std::string> bm;
        map<tars::Float, std::string> fm;
        vector<tars::Bool> bv;
        vector<tars::Int32> iv;
        vector<tars::Double> dv;
    };
    inline bool operator==(const JsonData&l, const JsonData&r)
    {
        return l.c == r.c && l.s == r.s && l.i == r.i && l.l == r.l && tars::TC_Common::equal(l.f,r.f) && tars::TC_Common::equal(l.d,r.d) && l.uc == r.uc && l.us == r.us && l.ui == r.ui && l.b == r.b && l.k == r.k && l.ss == r.ss && l.data == r.data && l.v == r.v && l.im == r.im && l.bm == r.bm && tars::TC_Common::equal(l.fm,r.fm) && l.bv == r.bv && l.iv == r.iv && tars::TC_Common::equal(l.dv,r.dv);
    }
    inline bool operator!=(const JsonData&l, const JsonData&r)
    {
        return !(l == r);
    }
    inline ostream& operator<<(ostream & os,const JsonData&r)
    {
        os << r.writeToJsonString();
        return os;
    }
    inline istream& operator>>(istream& is,JsonData&l)
    {
        std::istreambuf_iterator<char> eos;
        std::string s(std::istreambuf_iterator<char>(is), eos);
        l.readFromJsonString(s);
        return is;
    }

    struct JsonMap : public tars::TarsStructBase
    {
    public:
        static string className()
        {
            return "Test.JsonMap";
        }
        static string MD5()
        {
            return "5bf0437e83ccb7e533b35c9747197b50";
        }
        JsonMap()
        {
            resetDefautlt();
        }
        void resetDefautlt()
        {
            json.clear();
        }
        template<typename WriterT>
        void writeTo(tars::TarsOutputStream<WriterT>& _os) const
        {
            if (json.size() > 0)
            {
                _os.write(json, 0);
            }
        }
        template<typename ReaderT>
        void readFrom(tars::TarsInputStream<ReaderT>& _is)
        {
            resetDefautlt();
            _is.read(json, 0, false);
        }
        tars::JsonValueObjPtr writeToJson() const
        {
            tars::JsonValueObjPtr p = new tars::JsonValueObj();
            p->value["json"] = tars::JsonOutput::writeJson(json);
            return p;
        }
        string writeToJsonString() const
        {
            return tars::TC_Json::writeValue(writeToJson());
        }
        void readFromJson(const tars::JsonValuePtr & p, bool isRequire = true)
        {
            resetDefautlt();
            if(NULL == p.get() || p->getType() != tars::eJsonTypeObj)
            {
                char s[128];
                snprintf(s, sizeof(s), "read 'struct' type mismatch, get type: %d.", (p.get() ? p->getType() : 0));
                throw tars::TC_Json_Exception(s);
            }
            tars::JsonValueObjPtr pObj=tars::JsonValueObjPtr::dynamicCast(p);
            tars::JsonInput::readJson(json,pObj->value["json"], false);
        }
        void readFromJsonString(const string & str)
        {
            readFromJson(tars::TC_Json::getValue(str));
        }
        ostream& display(ostream& _os, int _level=0) const
        {
            tars::TarsDisplayer _ds(_os, _level);
            _ds.display(json,"json");
            return _os;
        }
        ostream& displaySimple(ostream& _os, int _level=0) const
        {
            tars::TarsDisplayer _ds(_os, _level);
            _ds.displaySimple(json, false);
            return _os;
        }
    public:
        map<Test::JsonKey, Test::JsonData> json;
    };
    inline bool operator==(const JsonMap&l, const JsonMap&r)
    {
        return l.json == r.json;
    }
    inline bool operator!=(const JsonMap&l, const JsonMap&r)
    {
        return !(l == r);
    }
    inline ostream& operator<<(ostream & os,const JsonMap&r)
    {
        os << r.writeToJsonString();
        return os;
    }
    inline istream& operator>>(istream& is,JsonMap&l)
    {
        std::istreambuf_iterator<char> eos;
        std::string s(std::istreambuf_iterator<char>(is), eos);
        l.readFromJsonString(s);
        return is;
    }


    /* callback of async proxy for client */
    class HelloPrxCallback: public tars::ServantProxyCallback
    {
    public:
        virtual ~HelloPrxCallback(){}
        virtual void callback_testConHash(tars::Int32 ret,  const std::string& sOut)
        { throw std::runtime_error("callback_testConHash() override incorrect."); }
        virtual void callback_testConHash_exception(tars::Int32 ret)
        { throw std::runtime_error("callback_testConHash_exception() override incorrect."); }

        virtual void callback_testCoro(tars::Bool ret,  const std::string& sOut)
        { throw std::runtime_error("callback_testCoro() override incorrect."); }
        virtual void callback_testCoro_exception(tars::Int32 ret)
        { throw std::runtime_error("callback_testCoro_exception() override incorrect."); }

        virtual void callback_testDyeing(tars::Int32 ret,  const std::string& strOut)
        { throw std::runtime_error("callback_testDyeing() override incorrect."); }
        virtual void callback_testDyeing_exception(tars::Int32 ret)
        { throw std::runtime_error("callback_testDyeing_exception() override incorrect."); }

        virtual void callback_testDyeingTrans(tars::Int32 ret)
        { throw std::runtime_error("callback_testDyeingTrans() override incorrect."); }
        virtual void callback_testDyeingTrans_exception(tars::Int32 ret)
        { throw std::runtime_error("callback_testDyeingTrans_exception() override incorrect."); }

        virtual void callback_testHello(tars::Int32 ret,  const std::string& r)
        { throw std::runtime_error("callback_testHello() override incorrect."); }
        virtual void callback_testHello_exception(tars::Int32 ret)
        { throw std::runtime_error("callback_testHello_exception() override incorrect."); }

        virtual void callback_testPid(tars::Int32 ret,  const std::string& r)
        { throw std::runtime_error("callback_testPid() override incorrect."); }
        virtual void callback_testPid_exception(tars::Int32 ret)
        { throw std::runtime_error("callback_testPid_exception() override incorrect."); }

        virtual void callback_testSyncTrans(tars::Int32 ret,  const std::string& r)
        { throw std::runtime_error("callback_testSyncTrans() override incorrect."); }
        virtual void callback_testSyncTrans_exception(tars::Int32 ret)
        { throw std::runtime_error("callback_testSyncTrans_exception() override incorrect."); }

        virtual void callback_testTimeout(tars::Int32 ret)
        { throw std::runtime_error("callback_testTimeout() override incorrect."); }
        virtual void callback_testTimeout_exception(tars::Int32 ret)
        { throw std::runtime_error("callback_testTimeout_exception() override incorrect."); }

        virtual void callback_testTrans(tars::Int32 ret,  const std::string& r)
        { throw std::runtime_error("callback_testTrans() override incorrect."); }
        virtual void callback_testTrans_exception(tars::Int32 ret)
        { throw std::runtime_error("callback_testTrans_exception() override incorrect."); }

    public:
        virtual const map<std::string, std::string> & getResponseContext() const
        {
            CallbackThreadData * pCbtd = CallbackThreadData::getData();
            assert(pCbtd != NULL);

            if(!pCbtd->getContextValid())
            {
                throw TC_Exception("cann't get response context");
            }
            return pCbtd->getResponseContext();
        }

    public:
        virtual int onDispatch(tars::ReqMessagePtr msg)
        {
            static ::std::string __Hello_all[]=
            {
                "testConHash",
                "testCoro",
                "testDyeing",
                "testDyeingTrans",
                "testHello",
                "testPid",
                "testSyncTrans",
                "testTimeout",
                "testTrans"
            };
            pair<string*, string*> r = equal_range(__Hello_all, __Hello_all+9, string(msg->request.sFuncName));
            if(r.first == r.second) return tars::TARSSERVERNOFUNCERR;
            switch(r.first - __Hello_all)
            {
                case 0:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testConHash_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    tars::Int32 _ret;
                    _is.read(_ret, 0, true);

                    std::string sOut;
                    _is.read(sOut, 1, true);
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                            _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testConHash", 0, _trace_param_, "");
                    }

                    CallbackThreadData * pCbtd = CallbackThreadData::getData();
                    assert(pCbtd != NULL);

                    pCbtd->setResponseContext(msg->response->context);

                    callback_testConHash(_ret, sOut);

                    pCbtd->delResponseContext();

                    return tars::TARSSERVERSUCCESS;

                }
                case 1:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testCoro_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    tars::Bool _ret = false;
                    _is.read(_ret, 0, true);

                    std::string sOut;
                    _is.read(sOut, 2, true);
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                            _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testCoro", 0, _trace_param_, "");
                    }

                    CallbackThreadData * pCbtd = CallbackThreadData::getData();
                    assert(pCbtd != NULL);

                    pCbtd->setResponseContext(msg->response->context);

                    callback_testCoro(_ret, sOut);

                    pCbtd->delResponseContext();

                    return tars::TARSSERVERSUCCESS;

                }
                case 2:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testDyeing_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    tars::Int32 _ret;
                    _is.read(_ret, 0, true);

                    std::string strOut;
                    _is.read(strOut, 2, true);
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                            _p_->value["strOut"] = tars::JsonOutput::writeJson(strOut);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeing", 0, _trace_param_, "");
                    }

                    CallbackThreadData * pCbtd = CallbackThreadData::getData();
                    assert(pCbtd != NULL);

                    pCbtd->setResponseContext(msg->response->context);

                    callback_testDyeing(_ret, strOut);

                    pCbtd->delResponseContext();

                    return tars::TARSSERVERSUCCESS;

                }
                case 3:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testDyeingTrans_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    tars::Int32 _ret;
                    _is.read(_ret, 0, true);

                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeingTrans", 0, _trace_param_, "");
                    }

                    CallbackThreadData * pCbtd = CallbackThreadData::getData();
                    assert(pCbtd != NULL);

                    pCbtd->setResponseContext(msg->response->context);

                    callback_testDyeingTrans(_ret);

                    pCbtd->delResponseContext();

                    return tars::TARSSERVERSUCCESS;

                }
                case 4:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testHello_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    tars::Int32 _ret;
                    _is.read(_ret, 0, true);

                    std::string r;
                    _is.read(r, 3, true);
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                            _p_->value["r"] = tars::JsonOutput::writeJson(r);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testHello", 0, _trace_param_, "");
                    }

                    CallbackThreadData * pCbtd = CallbackThreadData::getData();
                    assert(pCbtd != NULL);

                    pCbtd->setResponseContext(msg->response->context);

                    callback_testHello(_ret, r);

                    pCbtd->delResponseContext();

                    return tars::TARSSERVERSUCCESS;

                }
                case 5:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testPid_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    tars::Int32 _ret;
                    _is.read(_ret, 0, true);

                    std::string r;
                    _is.read(r, 1, true);
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                            _p_->value["r"] = tars::JsonOutput::writeJson(r);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testPid", 0, _trace_param_, "");
                    }

                    CallbackThreadData * pCbtd = CallbackThreadData::getData();
                    assert(pCbtd != NULL);

                    pCbtd->setResponseContext(msg->response->context);

                    callback_testPid(_ret, r);

                    pCbtd->delResponseContext();

                    return tars::TARSSERVERSUCCESS;

                }
                case 6:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testSyncTrans_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    tars::Int32 _ret;
                    _is.read(_ret, 0, true);

                    std::string r;
                    _is.read(r, 3, true);
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                            _p_->value["r"] = tars::JsonOutput::writeJson(r);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testSyncTrans", 0, _trace_param_, "");
                    }

                    CallbackThreadData * pCbtd = CallbackThreadData::getData();
                    assert(pCbtd != NULL);

                    pCbtd->setResponseContext(msg->response->context);

                    callback_testSyncTrans(_ret, r);

                    pCbtd->delResponseContext();

                    return tars::TARSSERVERSUCCESS;

                }
                case 7:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testTimeout_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    tars::Int32 _ret;
                    _is.read(_ret, 0, true);

                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTimeout", 0, _trace_param_, "");
                    }

                    CallbackThreadData * pCbtd = CallbackThreadData::getData();
                    assert(pCbtd != NULL);

                    pCbtd->setResponseContext(msg->response->context);

                    callback_testTimeout(_ret);

                    pCbtd->delResponseContext();

                    return tars::TARSSERVERSUCCESS;

                }
                case 8:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testTrans_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    tars::Int32 _ret;
                    _is.read(_ret, 0, true);

                    std::string r;
                    _is.read(r, 3, true);
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                            _p_->value["r"] = tars::JsonOutput::writeJson(r);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTrans", 0, _trace_param_, "");
                    }

                    CallbackThreadData * pCbtd = CallbackThreadData::getData();
                    assert(pCbtd != NULL);

                    pCbtd->setResponseContext(msg->response->context);

                    callback_testTrans(_ret, r);

                    pCbtd->delResponseContext();

                    return tars::TARSSERVERSUCCESS;

                }
            }
            return tars::TARSSERVERNOFUNCERR;
        }

    };
    typedef tars::TC_AutoPtr<HelloPrxCallback> HelloPrxCallbackPtr;

    //callback of promise async proxy for client
    class HelloPrxCallbackPromise: public tars::ServantProxyCallback
    {
    public:
        virtual ~HelloPrxCallbackPromise(){}
    public:
        struct PromisetestConHash: virtual public TC_HandleBase
        {
        public:
            tars::Int32 _ret;
            std::string sOut;
            map<std::string, std::string> _mRspContext;
        };
        
        typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestConHash > PromisetestConHashPtr;

        HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestConHashPtr > &promise)
        : _promise_testConHash(promise)
        {}
        
        virtual void callback_testConHash(const HelloPrxCallbackPromise::PromisetestConHashPtr &ptr)
        {
            _promise_testConHash.setValue(ptr);
        }
        virtual void callback_testConHash_exception(tars::Int32 ret)
        {
            std::string str("");
            str += "Function:testConHash_exception|Ret:";
            str += TC_Common::tostr(ret);
            _promise_testConHash.setException(tars::copyException(str, ret));
        }

    protected:
        tars::Promise< HelloPrxCallbackPromise::PromisetestConHashPtr > _promise_testConHash;

    public:
        struct PromisetestCoro: virtual public TC_HandleBase
        {
        public:
            tars::Bool _ret;
            std::string sOut;
            map<std::string, std::string> _mRspContext;
        };
        
        typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestCoro > PromisetestCoroPtr;

        HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestCoroPtr > &promise)
        : _promise_testCoro(promise)
        {}
        
        virtual void callback_testCoro(const HelloPrxCallbackPromise::PromisetestCoroPtr &ptr)
        {
            _promise_testCoro.setValue(ptr);
        }
        virtual void callback_testCoro_exception(tars::Int32 ret)
        {
            std::string str("");
            str += "Function:testCoro_exception|Ret:";
            str += TC_Common::tostr(ret);
            _promise_testCoro.setException(tars::copyException(str, ret));
        }

    protected:
        tars::Promise< HelloPrxCallbackPromise::PromisetestCoroPtr > _promise_testCoro;

    public:
        struct PromisetestDyeing: virtual public TC_HandleBase
        {
        public:
            tars::Int32 _ret;
            std::string strOut;
            map<std::string, std::string> _mRspContext;
        };
        
        typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestDyeing > PromisetestDyeingPtr;

        HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestDyeingPtr > &promise)
        : _promise_testDyeing(promise)
        {}
        
        virtual void callback_testDyeing(const HelloPrxCallbackPromise::PromisetestDyeingPtr &ptr)
        {
            _promise_testDyeing.setValue(ptr);
        }
        virtual void callback_testDyeing_exception(tars::Int32 ret)
        {
            std::string str("");
            str += "Function:testDyeing_exception|Ret:";
            str += TC_Common::tostr(ret);
            _promise_testDyeing.setException(tars::copyException(str, ret));
        }

    protected:
        tars::Promise< HelloPrxCallbackPromise::PromisetestDyeingPtr > _promise_testDyeing;

    public:
        struct PromisetestDyeingTrans: virtual public TC_HandleBase
        {
        public:
            tars::Int32 _ret;
            map<std::string, std::string> _mRspContext;
        };
        
        typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestDyeingTrans > PromisetestDyeingTransPtr;

        HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestDyeingTransPtr > &promise)
        : _promise_testDyeingTrans(promise)
        {}
        
        virtual void callback_testDyeingTrans(const HelloPrxCallbackPromise::PromisetestDyeingTransPtr &ptr)
        {
            _promise_testDyeingTrans.setValue(ptr);
        }
        virtual void callback_testDyeingTrans_exception(tars::Int32 ret)
        {
            std::string str("");
            str += "Function:testDyeingTrans_exception|Ret:";
            str += TC_Common::tostr(ret);
            _promise_testDyeingTrans.setException(tars::copyException(str, ret));
        }

    protected:
        tars::Promise< HelloPrxCallbackPromise::PromisetestDyeingTransPtr > _promise_testDyeingTrans;

    public:
        struct PromisetestHello: virtual public TC_HandleBase
        {
        public:
            tars::Int32 _ret;
            std::string r;
            map<std::string, std::string> _mRspContext;
        };
        
        typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestHello > PromisetestHelloPtr;

        HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestHelloPtr > &promise)
        : _promise_testHello(promise)
        {}
        
        virtual void callback_testHello(const HelloPrxCallbackPromise::PromisetestHelloPtr &ptr)
        {
            _promise_testHello.setValue(ptr);
        }
        virtual void callback_testHello_exception(tars::Int32 ret)
        {
            std::string str("");
            str += "Function:testHello_exception|Ret:";
            str += TC_Common::tostr(ret);
            _promise_testHello.setException(tars::copyException(str, ret));
        }

    protected:
        tars::Promise< HelloPrxCallbackPromise::PromisetestHelloPtr > _promise_testHello;

    public:
        struct PromisetestPid: virtual public TC_HandleBase
        {
        public:
            tars::Int32 _ret;
            std::string r;
            map<std::string, std::string> _mRspContext;
        };
        
        typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestPid > PromisetestPidPtr;

        HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestPidPtr > &promise)
        : _promise_testPid(promise)
        {}
        
        virtual void callback_testPid(const HelloPrxCallbackPromise::PromisetestPidPtr &ptr)
        {
            _promise_testPid.setValue(ptr);
        }
        virtual void callback_testPid_exception(tars::Int32 ret)
        {
            std::string str("");
            str += "Function:testPid_exception|Ret:";
            str += TC_Common::tostr(ret);
            _promise_testPid.setException(tars::copyException(str, ret));
        }

    protected:
        tars::Promise< HelloPrxCallbackPromise::PromisetestPidPtr > _promise_testPid;

    public:
        struct PromisetestSyncTrans: virtual public TC_HandleBase
        {
        public:
            tars::Int32 _ret;
            std::string r;
            map<std::string, std::string> _mRspContext;
        };
        
        typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestSyncTrans > PromisetestSyncTransPtr;

        HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestSyncTransPtr > &promise)
        : _promise_testSyncTrans(promise)
        {}
        
        virtual void callback_testSyncTrans(const HelloPrxCallbackPromise::PromisetestSyncTransPtr &ptr)
        {
            _promise_testSyncTrans.setValue(ptr);
        }
        virtual void callback_testSyncTrans_exception(tars::Int32 ret)
        {
            std::string str("");
            str += "Function:testSyncTrans_exception|Ret:";
            str += TC_Common::tostr(ret);
            _promise_testSyncTrans.setException(tars::copyException(str, ret));
        }

    protected:
        tars::Promise< HelloPrxCallbackPromise::PromisetestSyncTransPtr > _promise_testSyncTrans;

    public:
        struct PromisetestTimeout: virtual public TC_HandleBase
        {
        public:
            tars::Int32 _ret;
            map<std::string, std::string> _mRspContext;
        };
        
        typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestTimeout > PromisetestTimeoutPtr;

        HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestTimeoutPtr > &promise)
        : _promise_testTimeout(promise)
        {}
        
        virtual void callback_testTimeout(const HelloPrxCallbackPromise::PromisetestTimeoutPtr &ptr)
        {
            _promise_testTimeout.setValue(ptr);
        }
        virtual void callback_testTimeout_exception(tars::Int32 ret)
        {
            std::string str("");
            str += "Function:testTimeout_exception|Ret:";
            str += TC_Common::tostr(ret);
            _promise_testTimeout.setException(tars::copyException(str, ret));
        }

    protected:
        tars::Promise< HelloPrxCallbackPromise::PromisetestTimeoutPtr > _promise_testTimeout;

    public:
        struct PromisetestTrans: virtual public TC_HandleBase
        {
        public:
            tars::Int32 _ret;
            std::string r;
            map<std::string, std::string> _mRspContext;
        };
        
        typedef tars::TC_AutoPtr< HelloPrxCallbackPromise::PromisetestTrans > PromisetestTransPtr;

        HelloPrxCallbackPromise(const tars::Promise< HelloPrxCallbackPromise::PromisetestTransPtr > &promise)
        : _promise_testTrans(promise)
        {}
        
        virtual void callback_testTrans(const HelloPrxCallbackPromise::PromisetestTransPtr &ptr)
        {
            _promise_testTrans.setValue(ptr);
        }
        virtual void callback_testTrans_exception(tars::Int32 ret)
        {
            std::string str("");
            str += "Function:testTrans_exception|Ret:";
            str += TC_Common::tostr(ret);
            _promise_testTrans.setException(tars::copyException(str, ret));
        }

    protected:
        tars::Promise< HelloPrxCallbackPromise::PromisetestTransPtr > _promise_testTrans;

    public:
        virtual int onDispatch(tars::ReqMessagePtr msg)
        {
            static ::std::string __Hello_all[]=
            {
                "testConHash",
                "testCoro",
                "testDyeing",
                "testDyeingTrans",
                "testHello",
                "testPid",
                "testSyncTrans",
                "testTimeout",
                "testTrans"
            };

            pair<string*, string*> r = equal_range(__Hello_all, __Hello_all+9, string(msg->request.sFuncName));
            if(r.first == r.second) return tars::TARSSERVERNOFUNCERR;
            switch(r.first - __Hello_all)
            {
                case 0:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testConHash_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);

                    HelloPrxCallbackPromise::PromisetestConHashPtr ptr = new HelloPrxCallbackPromise::PromisetestConHash();

                    try
                    {
                        _is.read(ptr->_ret, 0, true);

                        _is.read(ptr->sOut, 1, true);
                    }
                    catch(std::exception &ex)
                    {
                        callback_testConHash_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testConHash_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    ptr->_mRspContext = msg->response->context;

                    callback_testConHash(ptr);

                    return tars::TARSSERVERSUCCESS;

                }
                case 1:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testCoro_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);

                    HelloPrxCallbackPromise::PromisetestCoroPtr ptr = new HelloPrxCallbackPromise::PromisetestCoro();

                    try
                    {
                        ptr->_ret  = false;
                        _is.read(ptr->_ret, 0, true);

                        _is.read(ptr->sOut, 2, true);
                    }
                    catch(std::exception &ex)
                    {
                        callback_testCoro_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testCoro_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    ptr->_mRspContext = msg->response->context;

                    callback_testCoro(ptr);

                    return tars::TARSSERVERSUCCESS;

                }
                case 2:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testDyeing_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);

                    HelloPrxCallbackPromise::PromisetestDyeingPtr ptr = new HelloPrxCallbackPromise::PromisetestDyeing();

                    try
                    {
                        _is.read(ptr->_ret, 0, true);

                        _is.read(ptr->strOut, 2, true);
                    }
                    catch(std::exception &ex)
                    {
                        callback_testDyeing_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testDyeing_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    ptr->_mRspContext = msg->response->context;

                    callback_testDyeing(ptr);

                    return tars::TARSSERVERSUCCESS;

                }
                case 3:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testDyeingTrans_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);

                    HelloPrxCallbackPromise::PromisetestDyeingTransPtr ptr = new HelloPrxCallbackPromise::PromisetestDyeingTrans();

                    try
                    {
                        _is.read(ptr->_ret, 0, true);

                    }
                    catch(std::exception &ex)
                    {
                        callback_testDyeingTrans_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testDyeingTrans_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    ptr->_mRspContext = msg->response->context;

                    callback_testDyeingTrans(ptr);

                    return tars::TARSSERVERSUCCESS;

                }
                case 4:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testHello_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);

                    HelloPrxCallbackPromise::PromisetestHelloPtr ptr = new HelloPrxCallbackPromise::PromisetestHello();

                    try
                    {
                        _is.read(ptr->_ret, 0, true);

                        _is.read(ptr->r, 3, true);
                    }
                    catch(std::exception &ex)
                    {
                        callback_testHello_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testHello_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    ptr->_mRspContext = msg->response->context;

                    callback_testHello(ptr);

                    return tars::TARSSERVERSUCCESS;

                }
                case 5:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testPid_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);

                    HelloPrxCallbackPromise::PromisetestPidPtr ptr = new HelloPrxCallbackPromise::PromisetestPid();

                    try
                    {
                        _is.read(ptr->_ret, 0, true);

                        _is.read(ptr->r, 1, true);
                    }
                    catch(std::exception &ex)
                    {
                        callback_testPid_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testPid_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    ptr->_mRspContext = msg->response->context;

                    callback_testPid(ptr);

                    return tars::TARSSERVERSUCCESS;

                }
                case 6:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testSyncTrans_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);

                    HelloPrxCallbackPromise::PromisetestSyncTransPtr ptr = new HelloPrxCallbackPromise::PromisetestSyncTrans();

                    try
                    {
                        _is.read(ptr->_ret, 0, true);

                        _is.read(ptr->r, 3, true);
                    }
                    catch(std::exception &ex)
                    {
                        callback_testSyncTrans_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testSyncTrans_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    ptr->_mRspContext = msg->response->context;

                    callback_testSyncTrans(ptr);

                    return tars::TARSSERVERSUCCESS;

                }
                case 7:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testTimeout_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);

                    HelloPrxCallbackPromise::PromisetestTimeoutPtr ptr = new HelloPrxCallbackPromise::PromisetestTimeout();

                    try
                    {
                        _is.read(ptr->_ret, 0, true);

                    }
                    catch(std::exception &ex)
                    {
                        callback_testTimeout_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testTimeout_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    ptr->_mRspContext = msg->response->context;

                    callback_testTimeout(ptr);

                    return tars::TARSSERVERSUCCESS;

                }
                case 8:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testTrans_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);

                    HelloPrxCallbackPromise::PromisetestTransPtr ptr = new HelloPrxCallbackPromise::PromisetestTrans();

                    try
                    {
                        _is.read(ptr->_ret, 0, true);

                        _is.read(ptr->r, 3, true);
                    }
                    catch(std::exception &ex)
                    {
                        callback_testTrans_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testTrans_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    ptr->_mRspContext = msg->response->context;

                    callback_testTrans(ptr);

                    return tars::TARSSERVERSUCCESS;

                }
            }
            return tars::TARSSERVERNOFUNCERR;
        }

    };
    typedef tars::TC_AutoPtr<HelloPrxCallbackPromise> HelloPrxCallbackPromisePtr;

    /* callback of coroutine async proxy for client */
    class HelloCoroPrxCallback: public HelloPrxCallback
    {
    public:
        virtual ~HelloCoroPrxCallback(){}
    public:
        virtual const map<std::string, std::string> & getResponseContext() const { return _mRspContext; }

        virtual void setResponseContext(const map<std::string, std::string> &mContext) { _mRspContext = mContext; }

    public:
        int onDispatch(tars::ReqMessagePtr msg)
        {
            static ::std::string __Hello_all[]=
            {
                "testConHash",
                "testCoro",
                "testDyeing",
                "testDyeingTrans",
                "testHello",
                "testPid",
                "testSyncTrans",
                "testTimeout",
                "testTrans"
            };

            pair<string*, string*> r = equal_range(__Hello_all, __Hello_all+9, string(msg->request.sFuncName));
            if(r.first == r.second) return tars::TARSSERVERNOFUNCERR;
            switch(r.first - __Hello_all)
            {
                case 0:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testConHash_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    try
                    {
                        tars::Int32 _ret;
                        _is.read(_ret, 0, true);

                        std::string sOut;
                        _is.read(sOut, 1, true);
                        setResponseContext(msg->response->context);

                        callback_testConHash(_ret, sOut);

                    }
                    catch(std::exception &ex)
                    {
                        callback_testConHash_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testConHash_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 1:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testCoro_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    try
                    {
                        tars::Bool _ret = false;
                        _is.read(_ret, 0, true);

                        std::string sOut;
                        _is.read(sOut, 2, true);
                        setResponseContext(msg->response->context);

                        callback_testCoro(_ret, sOut);

                    }
                    catch(std::exception &ex)
                    {
                        callback_testCoro_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testCoro_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 2:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testDyeing_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    try
                    {
                        tars::Int32 _ret;
                        _is.read(_ret, 0, true);

                        std::string strOut;
                        _is.read(strOut, 2, true);
                        setResponseContext(msg->response->context);

                        callback_testDyeing(_ret, strOut);

                    }
                    catch(std::exception &ex)
                    {
                        callback_testDyeing_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testDyeing_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 3:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testDyeingTrans_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    try
                    {
                        tars::Int32 _ret;
                        _is.read(_ret, 0, true);

                        setResponseContext(msg->response->context);

                        callback_testDyeingTrans(_ret);

                    }
                    catch(std::exception &ex)
                    {
                        callback_testDyeingTrans_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testDyeingTrans_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 4:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testHello_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    try
                    {
                        tars::Int32 _ret;
                        _is.read(_ret, 0, true);

                        std::string r;
                        _is.read(r, 3, true);
                        setResponseContext(msg->response->context);

                        callback_testHello(_ret, r);

                    }
                    catch(std::exception &ex)
                    {
                        callback_testHello_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testHello_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 5:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testPid_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    try
                    {
                        tars::Int32 _ret;
                        _is.read(_ret, 0, true);

                        std::string r;
                        _is.read(r, 1, true);
                        setResponseContext(msg->response->context);

                        callback_testPid(_ret, r);

                    }
                    catch(std::exception &ex)
                    {
                        callback_testPid_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testPid_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 6:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testSyncTrans_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    try
                    {
                        tars::Int32 _ret;
                        _is.read(_ret, 0, true);

                        std::string r;
                        _is.read(r, 3, true);
                        setResponseContext(msg->response->context);

                        callback_testSyncTrans(_ret, r);

                    }
                    catch(std::exception &ex)
                    {
                        callback_testSyncTrans_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testSyncTrans_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 7:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testTimeout_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    try
                    {
                        tars::Int32 _ret;
                        _is.read(_ret, 0, true);

                        setResponseContext(msg->response->context);

                        callback_testTimeout(_ret);

                    }
                    catch(std::exception &ex)
                    {
                        callback_testTimeout_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testTimeout_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 8:
                {
                    if (msg->response->iRet != tars::TARSSERVERSUCCESS)
                    {
                        callback_testTrans_exception(msg->response->iRet);

                        return msg->response->iRet;
                    }
                    tars::TarsInputStream<tars::BufferReader> _is;

                    _is.setBuffer(msg->response->sBuffer);
                    try
                    {
                        tars::Int32 _ret;
                        _is.read(_ret, 0, true);

                        std::string r;
                        _is.read(r, 3, true);
                        setResponseContext(msg->response->context);

                        callback_testTrans(_ret, r);

                    }
                    catch(std::exception &ex)
                    {
                        callback_testTrans_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }
                    catch(...)
                    {
                        callback_testTrans_exception(tars::TARSCLIENTDECODEERR);

                        return tars::TARSCLIENTDECODEERR;
                    }

                    return tars::TARSSERVERSUCCESS;

                }
            }
            return tars::TARSSERVERNOFUNCERR;
        }

    protected:
        map<std::string, std::string> _mRspContext;
    };
    typedef tars::TC_AutoPtr<HelloCoroPrxCallback> HelloCoroPrxCallbackPtr;

    /* proxy for client */
    class HelloProxy : public tars::ServantProxy
    {
    public:
        typedef map<string, string> TARS_CONTEXT;
        tars::Int32 testConHash(std::string &sOut,const map<string, string> &context = TARS_CONTEXT(),map<string, string> * pResponseContext = NULL)
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(sOut, 1);
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testConHash", 0, _trace_param_, "");
            }

            std::map<string, string> _mStatus;
            shared_ptr<tars::ResponsePacket> rep = tars_invoke(tars::TARSNORMAL,"testConHash", _os, context, _mStatus);
            if(pResponseContext)
            {
                pResponseContext->swap(rep->context);
            }

            tars::TarsInputStream<tars::BufferReader> _is;
            _is.setBuffer(rep->sBuffer);
            tars::Int32 _ret;
            _is.read(_ret, 0, true);
            _is.read(sOut, 1, true);
            if (pSptd && pSptd->_traceCall)
            {
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testConHash", 0, _trace_param_, "");
            }

            return _ret;
        }

        void async_testConHash(HelloPrxCallbackPtr callback,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            std::map<string, string> _mStatus;
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testConHash", 0, _trace_param_, "");
            }
            tars_invoke_async(tars::TARSNORMAL,"testConHash", _os, context, _mStatus, callback);
        }
        
        tars::Future< HelloPrxCallbackPromise::PromisetestConHashPtr > promise_async_testConHash(const map<string, string>& context)
        {
            tars::Promise< HelloPrxCallbackPromise::PromisetestConHashPtr > promise;
            HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise);

            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testConHash", _os, context, _mStatus, callback);

            return promise.getFuture();
        }

        void coro_testConHash(HelloCoroPrxCallbackPtr callback,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testConHash", _os, context, _mStatus, callback, true);
        }

        tars::Bool testCoro(const std::string & sIn,std::string &sOut,const map<string, string> &context = TARS_CONTEXT(),map<string, string> * pResponseContext = NULL)
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(sIn, 1);
            _os.write(sOut, 2);
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value["sIn"] = tars::JsonOutput::writeJson(sIn);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testCoro", 0, _trace_param_, "");
            }

            std::map<string, string> _mStatus;
            shared_ptr<tars::ResponsePacket> rep = tars_invoke(tars::TARSNORMAL,"testCoro", _os, context, _mStatus);
            if(pResponseContext)
            {
                pResponseContext->swap(rep->context);
            }

            tars::TarsInputStream<tars::BufferReader> _is;
            _is.setBuffer(rep->sBuffer);
            tars::Bool _ret = false;
            _is.read(_ret, 0, true);
            _is.read(sOut, 2, true);
            if (pSptd && pSptd->_traceCall)
            {
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testCoro", 0, _trace_param_, "");
            }

            return _ret;
        }

        void async_testCoro(HelloPrxCallbackPtr callback,const std::string &sIn,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(sIn, 1);
            std::map<string, string> _mStatus;
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value["sIn"] = tars::JsonOutput::writeJson(sIn);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testCoro", 0, _trace_param_, "");
            }
            tars_invoke_async(tars::TARSNORMAL,"testCoro", _os, context, _mStatus, callback);
        }
        
        tars::Future< HelloPrxCallbackPromise::PromisetestCoroPtr > promise_async_testCoro(const std::string &sIn,const map<string, string>& context)
        {
            tars::Promise< HelloPrxCallbackPromise::PromisetestCoroPtr > promise;
            HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise);

            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(sIn, 1);
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testCoro", _os, context, _mStatus, callback);

            return promise.getFuture();
        }

        void coro_testCoro(HelloCoroPrxCallbackPtr callback,const std::string &sIn,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(sIn, 1);
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testCoro", _os, context, _mStatus, callback, true);
        }

        tars::Int32 testDyeing(const std::string & strIn,std::string &strOut,const map<string, string> &context = TARS_CONTEXT(),map<string, string> * pResponseContext = NULL)
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(strIn, 1);
            _os.write(strOut, 2);
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value["strIn"] = tars::JsonOutput::writeJson(strIn);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testDyeing", 0, _trace_param_, "");
            }

            std::map<string, string> _mStatus;
            _mStatus.insert(std::make_pair(ServantProxy::STATUS_GRID_KEY, strIn));
            shared_ptr<tars::ResponsePacket> rep = tars_invoke(tars::TARSNORMAL,"testDyeing", _os, context, _mStatus);
            if(pResponseContext)
            {
                pResponseContext->swap(rep->context);
            }

            tars::TarsInputStream<tars::BufferReader> _is;
            _is.setBuffer(rep->sBuffer);
            tars::Int32 _ret;
            _is.read(_ret, 0, true);
            _is.read(strOut, 2, true);
            if (pSptd && pSptd->_traceCall)
            {
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["strOut"] = tars::JsonOutput::writeJson(strOut);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testDyeing", 0, _trace_param_, "");
            }

            return _ret;
        }

        void async_testDyeing(HelloPrxCallbackPtr callback,const std::string &strIn,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(strIn, 1);
            std::map<string, string> _mStatus;
            _mStatus.insert(std::make_pair(ServantProxy::STATUS_GRID_KEY, strIn));
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value["strIn"] = tars::JsonOutput::writeJson(strIn);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testDyeing", 0, _trace_param_, "");
            }
            tars_invoke_async(tars::TARSNORMAL,"testDyeing", _os, context, _mStatus, callback);
        }
        
        tars::Future< HelloPrxCallbackPromise::PromisetestDyeingPtr > promise_async_testDyeing(const std::string &strIn,const map<string, string>& context)
        {
            tars::Promise< HelloPrxCallbackPromise::PromisetestDyeingPtr > promise;
            HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise);

            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(strIn, 1);
            std::map<string, string> _mStatus;
            _mStatus.insert(std::make_pair(ServantProxy::STATUS_GRID_KEY, strIn));
            tars_invoke_async(tars::TARSNORMAL,"testDyeing", _os, context, _mStatus, callback);

            return promise.getFuture();
        }

        void coro_testDyeing(HelloCoroPrxCallbackPtr callback,const std::string &strIn,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(strIn, 1);
            std::map<string, string> _mStatus;
            _mStatus.insert(std::make_pair(ServantProxy::STATUS_GRID_KEY, strIn));
            tars_invoke_async(tars::TARSNORMAL,"testDyeing", _os, context, _mStatus, callback, true);
        }

        tars::Int32 testDyeingTrans(const map<string, string> &context = TARS_CONTEXT(),map<string, string> * pResponseContext = NULL)
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testDyeingTrans", 0, _trace_param_, "");
            }

            std::map<string, string> _mStatus;
            shared_ptr<tars::ResponsePacket> rep = tars_invoke(tars::TARSNORMAL,"testDyeingTrans", _os, context, _mStatus);
            if(pResponseContext)
            {
                pResponseContext->swap(rep->context);
            }

            tars::TarsInputStream<tars::BufferReader> _is;
            _is.setBuffer(rep->sBuffer);
            tars::Int32 _ret;
            _is.read(_ret, 0, true);
            if (pSptd && pSptd->_traceCall)
            {
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testDyeingTrans", 0, _trace_param_, "");
            }

            return _ret;
        }

        void async_testDyeingTrans(HelloPrxCallbackPtr callback,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            std::map<string, string> _mStatus;
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testDyeingTrans", 0, _trace_param_, "");
            }
            tars_invoke_async(tars::TARSNORMAL,"testDyeingTrans", _os, context, _mStatus, callback);
        }
        
        tars::Future< HelloPrxCallbackPromise::PromisetestDyeingTransPtr > promise_async_testDyeingTrans(const map<string, string>& context)
        {
            tars::Promise< HelloPrxCallbackPromise::PromisetestDyeingTransPtr > promise;
            HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise);

            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testDyeingTrans", _os, context, _mStatus, callback);

            return promise.getFuture();
        }

        void coro_testDyeingTrans(HelloCoroPrxCallbackPtr callback,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testDyeingTrans", _os, context, _mStatus, callback, true);
        }

        tars::Int32 testHello(tars::Int32 index,const std::string & s,std::string &r,const map<string, string> &context = TARS_CONTEXT(),map<string, string> * pResponseContext = NULL)
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(index, 1);
            _os.write(s, 2);
            _os.write(r, 3);
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value["index"] = tars::JsonOutput::writeJson(index);
                    _p_->value["s"] = tars::JsonOutput::writeJson(s);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testHello", 0, _trace_param_, "");
            }

            std::map<string, string> _mStatus;
            shared_ptr<tars::ResponsePacket> rep = tars_invoke(tars::TARSNORMAL,"testHello", _os, context, _mStatus);
            if(pResponseContext)
            {
                pResponseContext->swap(rep->context);
            }

            tars::TarsInputStream<tars::BufferReader> _is;
            _is.setBuffer(rep->sBuffer);
            tars::Int32 _ret;
            _is.read(_ret, 0, true);
            _is.read(r, 3, true);
            if (pSptd && pSptd->_traceCall)
            {
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["r"] = tars::JsonOutput::writeJson(r);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testHello", 0, _trace_param_, "");
            }

            return _ret;
        }

        void async_testHello(HelloPrxCallbackPtr callback,tars::Int32 index,const std::string &s,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(index, 1);
            _os.write(s, 2);
            std::map<string, string> _mStatus;
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value["index"] = tars::JsonOutput::writeJson(index);
                    _p_->value["s"] = tars::JsonOutput::writeJson(s);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testHello", 0, _trace_param_, "");
            }
            tars_invoke_async(tars::TARSNORMAL,"testHello", _os, context, _mStatus, callback);
        }
        
        tars::Future< HelloPrxCallbackPromise::PromisetestHelloPtr > promise_async_testHello(tars::Int32 index,const std::string &s,const map<string, string>& context)
        {
            tars::Promise< HelloPrxCallbackPromise::PromisetestHelloPtr > promise;
            HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise);

            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(index, 1);
            _os.write(s, 2);
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testHello", _os, context, _mStatus, callback);

            return promise.getFuture();
        }

        void coro_testHello(HelloCoroPrxCallbackPtr callback,tars::Int32 index,const std::string &s,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(index, 1);
            _os.write(s, 2);
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testHello", _os, context, _mStatus, callback, true);
        }

        tars::Int32 testPid(std::string &r,const map<string, string> &context = TARS_CONTEXT(),map<string, string> * pResponseContext = NULL)
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(r, 1);
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testPid", 0, _trace_param_, "");
            }

            std::map<string, string> _mStatus;
            shared_ptr<tars::ResponsePacket> rep = tars_invoke(tars::TARSNORMAL,"testPid", _os, context, _mStatus);
            if(pResponseContext)
            {
                pResponseContext->swap(rep->context);
            }

            tars::TarsInputStream<tars::BufferReader> _is;
            _is.setBuffer(rep->sBuffer);
            tars::Int32 _ret;
            _is.read(_ret, 0, true);
            _is.read(r, 1, true);
            if (pSptd && pSptd->_traceCall)
            {
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["r"] = tars::JsonOutput::writeJson(r);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testPid", 0, _trace_param_, "");
            }

            return _ret;
        }

        void async_testPid(HelloPrxCallbackPtr callback,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            std::map<string, string> _mStatus;
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testPid", 0, _trace_param_, "");
            }
            tars_invoke_async(tars::TARSNORMAL,"testPid", _os, context, _mStatus, callback);
        }
        
        tars::Future< HelloPrxCallbackPromise::PromisetestPidPtr > promise_async_testPid(const map<string, string>& context)
        {
            tars::Promise< HelloPrxCallbackPromise::PromisetestPidPtr > promise;
            HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise);

            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testPid", _os, context, _mStatus, callback);

            return promise.getFuture();
        }

        void coro_testPid(HelloCoroPrxCallbackPtr callback,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testPid", _os, context, _mStatus, callback, true);
        }

        tars::Int32 testSyncTrans(tars::Int32 index,const std::string & s,std::string &r,const map<string, string> &context = TARS_CONTEXT(),map<string, string> * pResponseContext = NULL)
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(index, 1);
            _os.write(s, 2);
            _os.write(r, 3);
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value["index"] = tars::JsonOutput::writeJson(index);
                    _p_->value["s"] = tars::JsonOutput::writeJson(s);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testSyncTrans", 0, _trace_param_, "");
            }

            std::map<string, string> _mStatus;
            shared_ptr<tars::ResponsePacket> rep = tars_invoke(tars::TARSNORMAL,"testSyncTrans", _os, context, _mStatus);
            if(pResponseContext)
            {
                pResponseContext->swap(rep->context);
            }

            tars::TarsInputStream<tars::BufferReader> _is;
            _is.setBuffer(rep->sBuffer);
            tars::Int32 _ret;
            _is.read(_ret, 0, true);
            _is.read(r, 3, true);
            if (pSptd && pSptd->_traceCall)
            {
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["r"] = tars::JsonOutput::writeJson(r);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testSyncTrans", 0, _trace_param_, "");
            }

            return _ret;
        }

        void async_testSyncTrans(HelloPrxCallbackPtr callback,tars::Int32 index,const std::string &s,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(index, 1);
            _os.write(s, 2);
            std::map<string, string> _mStatus;
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value["index"] = tars::JsonOutput::writeJson(index);
                    _p_->value["s"] = tars::JsonOutput::writeJson(s);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testSyncTrans", 0, _trace_param_, "");
            }
            tars_invoke_async(tars::TARSNORMAL,"testSyncTrans", _os, context, _mStatus, callback);
        }
        
        tars::Future< HelloPrxCallbackPromise::PromisetestSyncTransPtr > promise_async_testSyncTrans(tars::Int32 index,const std::string &s,const map<string, string>& context)
        {
            tars::Promise< HelloPrxCallbackPromise::PromisetestSyncTransPtr > promise;
            HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise);

            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(index, 1);
            _os.write(s, 2);
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testSyncTrans", _os, context, _mStatus, callback);

            return promise.getFuture();
        }

        void coro_testSyncTrans(HelloCoroPrxCallbackPtr callback,tars::Int32 index,const std::string &s,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(index, 1);
            _os.write(s, 2);
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testSyncTrans", _os, context, _mStatus, callback, true);
        }

        tars::Int32 testTimeout(tars::Int32 timeout,const map<string, string> &context = TARS_CONTEXT(),map<string, string> * pResponseContext = NULL)
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(timeout, 1);
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value["timeout"] = tars::JsonOutput::writeJson(timeout);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testTimeout", 0, _trace_param_, "");
            }

            std::map<string, string> _mStatus;
            shared_ptr<tars::ResponsePacket> rep = tars_invoke(tars::TARSNORMAL,"testTimeout", _os, context, _mStatus);
            if(pResponseContext)
            {
                pResponseContext->swap(rep->context);
            }

            tars::TarsInputStream<tars::BufferReader> _is;
            _is.setBuffer(rep->sBuffer);
            tars::Int32 _ret;
            _is.read(_ret, 0, true);
            if (pSptd && pSptd->_traceCall)
            {
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testTimeout", 0, _trace_param_, "");
            }

            return _ret;
        }

        void async_testTimeout(HelloPrxCallbackPtr callback,tars::Int32 timeout,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(timeout, 1);
            std::map<string, string> _mStatus;
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value["timeout"] = tars::JsonOutput::writeJson(timeout);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testTimeout", 0, _trace_param_, "");
            }
            tars_invoke_async(tars::TARSNORMAL,"testTimeout", _os, context, _mStatus, callback);
        }
        
        tars::Future< HelloPrxCallbackPromise::PromisetestTimeoutPtr > promise_async_testTimeout(tars::Int32 timeout,const map<string, string>& context)
        {
            tars::Promise< HelloPrxCallbackPromise::PromisetestTimeoutPtr > promise;
            HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise);

            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(timeout, 1);
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testTimeout", _os, context, _mStatus, callback);

            return promise.getFuture();
        }

        void coro_testTimeout(HelloCoroPrxCallbackPtr callback,tars::Int32 timeout,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(timeout, 1);
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testTimeout", _os, context, _mStatus, callback, true);
        }

        tars::Int32 testTrans(tars::Int32 index,const std::string & s,std::string &r,const map<string, string> &context = TARS_CONTEXT(),map<string, string> * pResponseContext = NULL)
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(index, 1);
            _os.write(s, 2);
            _os.write(r, 3);
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value["index"] = tars::JsonOutput::writeJson(index);
                    _p_->value["s"] = tars::JsonOutput::writeJson(s);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testTrans", 0, _trace_param_, "");
            }

            std::map<string, string> _mStatus;
            shared_ptr<tars::ResponsePacket> rep = tars_invoke(tars::TARSNORMAL,"testTrans", _os, context, _mStatus);
            if(pResponseContext)
            {
                pResponseContext->swap(rep->context);
            }

            tars::TarsInputStream<tars::BufferReader> _is;
            _is.setBuffer(rep->sBuffer);
            tars::Int32 _ret;
            _is.read(_ret, 0, true);
            _is.read(r, 3, true);
            if (pSptd && pSptd->_traceCall)
            {
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CR, _is.size());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["r"] = tars::JsonOutput::writeJson(r);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CR), TRACE_ANNOTATION_CR, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testTrans", 0, _trace_param_, "");
            }

            return _ret;
        }

        void async_testTrans(HelloPrxCallbackPtr callback,tars::Int32 index,const std::string &s,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(index, 1);
            _os.write(s, 2);
            std::map<string, string> _mStatus;
            ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
            if (pSptd && pSptd->_traceCall)
            {
                pSptd->newSpan();
                string _trace_param_;
                int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_CS, _os.getLength());
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value["index"] = tars::JsonOutput::writeJson(index);
                    _p_->value["s"] = tars::JsonOutput::writeJson(s);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_CS), TRACE_ANNOTATION_CS, ServerConfig::Application + "." + ServerConfig::ServerName, tars_name(), "testTrans", 0, _trace_param_, "");
            }
            tars_invoke_async(tars::TARSNORMAL,"testTrans", _os, context, _mStatus, callback);
        }
        
        tars::Future< HelloPrxCallbackPromise::PromisetestTransPtr > promise_async_testTrans(tars::Int32 index,const std::string &s,const map<string, string>& context)
        {
            tars::Promise< HelloPrxCallbackPromise::PromisetestTransPtr > promise;
            HelloPrxCallbackPromisePtr callback = new HelloPrxCallbackPromise(promise);

            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(index, 1);
            _os.write(s, 2);
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testTrans", _os, context, _mStatus, callback);

            return promise.getFuture();
        }

        void coro_testTrans(HelloCoroPrxCallbackPtr callback,tars::Int32 index,const std::string &s,const map<string, string>& context = TARS_CONTEXT())
        {
            tars::TarsOutputStream<tars::BufferWriterVector> _os;
            _os.write(index, 1);
            _os.write(s, 2);
            std::map<string, string> _mStatus;
            tars_invoke_async(tars::TARSNORMAL,"testTrans", _os, context, _mStatus, callback, true);
        }

        HelloProxy* tars_hash(int64_t key)
        {
            return (HelloProxy*)ServantProxy::tars_hash(key);
        }

        HelloProxy* tars_consistent_hash(int64_t key)
        {
            return (HelloProxy*)ServantProxy::tars_consistent_hash(key);
        }

        HelloProxy* tars_open_trace(bool traceParam = false)
        {
            return (HelloProxy*)ServantProxy::tars_open_trace(traceParam);
        }

        HelloProxy* tars_set_timeout(int msecond)
        {
            return (HelloProxy*)ServantProxy::tars_set_timeout(msecond);
        }

        static const char* tars_prxname() { return "HelloProxy"; }
    };
    typedef tars::TC_AutoPtr<HelloProxy> HelloPrx;

    /* servant for server */
    class Hello : public tars::Servant
    {
    public:
        virtual ~Hello(){}
        virtual tars::Int32 testConHash(std::string &sOut,tars::TarsCurrentPtr current) = 0;
        static void async_response_testConHash(tars::TarsCurrentPtr current, tars::Int32 _ret, const std::string &sOut)
        {
            size_t _rsp_len_ = 0;
            if (current->getRequestVersion() == TUPVERSION )
            {
                UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                tarsAttr.setVersion(current->getRequestVersion());
                tarsAttr.put("", _ret);
                tarsAttr.put("tars_ret", _ret);
                tarsAttr.put("sOut", sOut);

                vector<char> sTupResponseBuffer;
                tarsAttr.encode(sTupResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer);
                _rsp_len_ = sTupResponseBuffer.size();
            }
            else if (current->getRequestVersion() == JSONVERSION)
            {
                tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                _p->value["sOut"] = tars::JsonOutput::writeJson(sOut);
                _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                vector<char> sJsonResponseBuffer;
                tars::TC_Json::writeValue(_p, sJsonResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer);
                _rsp_len_ = sJsonResponseBuffer.size();
            }
            else
            {
                tars::TarsOutputStream<tars::BufferWriterVector> _os;
                _os.write(_ret, 0);

                _os.write(sOut, 1);

                current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer());
                _rsp_len_ = _os.getLength();
            }
            if (current->isTraced())
            {
                string _trace_param_;
                int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_);
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testConHash", 0, _trace_param_, "");
            }

        }

        virtual tars::Bool testCoro(const std::string & sIn,std::string &sOut,tars::TarsCurrentPtr current) = 0;
        static void async_response_testCoro(tars::TarsCurrentPtr current, tars::Bool _ret, const std::string &sOut)
        {
            size_t _rsp_len_ = 0;
            if (current->getRequestVersion() == TUPVERSION )
            {
                UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                tarsAttr.setVersion(current->getRequestVersion());
                tarsAttr.put("", _ret);
                tarsAttr.put("tars_ret", _ret);
                tarsAttr.put("sOut", sOut);

                vector<char> sTupResponseBuffer;
                tarsAttr.encode(sTupResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer);
                _rsp_len_ = sTupResponseBuffer.size();
            }
            else if (current->getRequestVersion() == JSONVERSION)
            {
                tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                _p->value["sOut"] = tars::JsonOutput::writeJson(sOut);
                _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                vector<char> sJsonResponseBuffer;
                tars::TC_Json::writeValue(_p, sJsonResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer);
                _rsp_len_ = sJsonResponseBuffer.size();
            }
            else
            {
                tars::TarsOutputStream<tars::BufferWriterVector> _os;
                _os.write(_ret, 0);

                _os.write(sOut, 2);

                current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer());
                _rsp_len_ = _os.getLength();
            }
            if (current->isTraced())
            {
                string _trace_param_;
                int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_);
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testCoro", 0, _trace_param_, "");
            }

        }

        virtual tars::Int32 testDyeing(const std::string & strIn,std::string &strOut,tars::TarsCurrentPtr current) = 0;
        static void async_response_testDyeing(tars::TarsCurrentPtr current, tars::Int32 _ret, const std::string &strOut)
        {
            size_t _rsp_len_ = 0;
            if (current->getRequestVersion() == TUPVERSION )
            {
                UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                tarsAttr.setVersion(current->getRequestVersion());
                tarsAttr.put("", _ret);
                tarsAttr.put("tars_ret", _ret);
                tarsAttr.put("strOut", strOut);

                vector<char> sTupResponseBuffer;
                tarsAttr.encode(sTupResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer);
                _rsp_len_ = sTupResponseBuffer.size();
            }
            else if (current->getRequestVersion() == JSONVERSION)
            {
                tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                _p->value["strOut"] = tars::JsonOutput::writeJson(strOut);
                _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                vector<char> sJsonResponseBuffer;
                tars::TC_Json::writeValue(_p, sJsonResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer);
                _rsp_len_ = sJsonResponseBuffer.size();
            }
            else
            {
                tars::TarsOutputStream<tars::BufferWriterVector> _os;
                _os.write(_ret, 0);

                _os.write(strOut, 2);

                current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer());
                _rsp_len_ = _os.getLength();
            }
            if (current->isTraced())
            {
                string _trace_param_;
                int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_);
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["strOut"] = tars::JsonOutput::writeJson(strOut);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeing", 0, _trace_param_, "");
            }

        }

        virtual tars::Int32 testDyeingTrans(tars::TarsCurrentPtr current) = 0;
        static void async_response_testDyeingTrans(tars::TarsCurrentPtr current, tars::Int32 _ret)
        {
            size_t _rsp_len_ = 0;
            if (current->getRequestVersion() == TUPVERSION )
            {
                UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                tarsAttr.setVersion(current->getRequestVersion());
                tarsAttr.put("", _ret);
                tarsAttr.put("tars_ret", _ret);

                vector<char> sTupResponseBuffer;
                tarsAttr.encode(sTupResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer);
                _rsp_len_ = sTupResponseBuffer.size();
            }
            else if (current->getRequestVersion() == JSONVERSION)
            {
                tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                vector<char> sJsonResponseBuffer;
                tars::TC_Json::writeValue(_p, sJsonResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer);
                _rsp_len_ = sJsonResponseBuffer.size();
            }
            else
            {
                tars::TarsOutputStream<tars::BufferWriterVector> _os;
                _os.write(_ret, 0);

                current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer());
                _rsp_len_ = _os.getLength();
            }
            if (current->isTraced())
            {
                string _trace_param_;
                int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_);
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeingTrans", 0, _trace_param_, "");
            }

        }

        virtual tars::Int32 testHello(tars::Int32 index,const std::string & s,std::string &r,tars::TarsCurrentPtr current) = 0;
        static void async_response_testHello(tars::TarsCurrentPtr current, tars::Int32 _ret, const std::string &r)
        {
            size_t _rsp_len_ = 0;
            if (current->getRequestVersion() == TUPVERSION )
            {
                UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                tarsAttr.setVersion(current->getRequestVersion());
                tarsAttr.put("", _ret);
                tarsAttr.put("tars_ret", _ret);
                tarsAttr.put("r", r);

                vector<char> sTupResponseBuffer;
                tarsAttr.encode(sTupResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer);
                _rsp_len_ = sTupResponseBuffer.size();
            }
            else if (current->getRequestVersion() == JSONVERSION)
            {
                tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                _p->value["r"] = tars::JsonOutput::writeJson(r);
                _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                vector<char> sJsonResponseBuffer;
                tars::TC_Json::writeValue(_p, sJsonResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer);
                _rsp_len_ = sJsonResponseBuffer.size();
            }
            else
            {
                tars::TarsOutputStream<tars::BufferWriterVector> _os;
                _os.write(_ret, 0);

                _os.write(r, 3);

                current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer());
                _rsp_len_ = _os.getLength();
            }
            if (current->isTraced())
            {
                string _trace_param_;
                int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_);
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["r"] = tars::JsonOutput::writeJson(r);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testHello", 0, _trace_param_, "");
            }

        }

        virtual tars::Int32 testPid(std::string &r,tars::TarsCurrentPtr current) = 0;
        static void async_response_testPid(tars::TarsCurrentPtr current, tars::Int32 _ret, const std::string &r)
        {
            size_t _rsp_len_ = 0;
            if (current->getRequestVersion() == TUPVERSION )
            {
                UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                tarsAttr.setVersion(current->getRequestVersion());
                tarsAttr.put("", _ret);
                tarsAttr.put("tars_ret", _ret);
                tarsAttr.put("r", r);

                vector<char> sTupResponseBuffer;
                tarsAttr.encode(sTupResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer);
                _rsp_len_ = sTupResponseBuffer.size();
            }
            else if (current->getRequestVersion() == JSONVERSION)
            {
                tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                _p->value["r"] = tars::JsonOutput::writeJson(r);
                _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                vector<char> sJsonResponseBuffer;
                tars::TC_Json::writeValue(_p, sJsonResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer);
                _rsp_len_ = sJsonResponseBuffer.size();
            }
            else
            {
                tars::TarsOutputStream<tars::BufferWriterVector> _os;
                _os.write(_ret, 0);

                _os.write(r, 1);

                current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer());
                _rsp_len_ = _os.getLength();
            }
            if (current->isTraced())
            {
                string _trace_param_;
                int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_);
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["r"] = tars::JsonOutput::writeJson(r);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testPid", 0, _trace_param_, "");
            }

        }

        virtual tars::Int32 testSyncTrans(tars::Int32 index,const std::string & s,std::string &r,tars::TarsCurrentPtr current) = 0;
        static void async_response_testSyncTrans(tars::TarsCurrentPtr current, tars::Int32 _ret, const std::string &r)
        {
            size_t _rsp_len_ = 0;
            if (current->getRequestVersion() == TUPVERSION )
            {
                UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                tarsAttr.setVersion(current->getRequestVersion());
                tarsAttr.put("", _ret);
                tarsAttr.put("tars_ret", _ret);
                tarsAttr.put("r", r);

                vector<char> sTupResponseBuffer;
                tarsAttr.encode(sTupResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer);
                _rsp_len_ = sTupResponseBuffer.size();
            }
            else if (current->getRequestVersion() == JSONVERSION)
            {
                tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                _p->value["r"] = tars::JsonOutput::writeJson(r);
                _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                vector<char> sJsonResponseBuffer;
                tars::TC_Json::writeValue(_p, sJsonResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer);
                _rsp_len_ = sJsonResponseBuffer.size();
            }
            else
            {
                tars::TarsOutputStream<tars::BufferWriterVector> _os;
                _os.write(_ret, 0);

                _os.write(r, 3);

                current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer());
                _rsp_len_ = _os.getLength();
            }
            if (current->isTraced())
            {
                string _trace_param_;
                int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_);
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["r"] = tars::JsonOutput::writeJson(r);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testSyncTrans", 0, _trace_param_, "");
            }

        }

        virtual tars::Int32 testTimeout(tars::Int32 timeout,tars::TarsCurrentPtr current) = 0;
        static void async_response_testTimeout(tars::TarsCurrentPtr current, tars::Int32 _ret)
        {
            size_t _rsp_len_ = 0;
            if (current->getRequestVersion() == TUPVERSION )
            {
                UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                tarsAttr.setVersion(current->getRequestVersion());
                tarsAttr.put("", _ret);
                tarsAttr.put("tars_ret", _ret);

                vector<char> sTupResponseBuffer;
                tarsAttr.encode(sTupResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer);
                _rsp_len_ = sTupResponseBuffer.size();
            }
            else if (current->getRequestVersion() == JSONVERSION)
            {
                tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                vector<char> sJsonResponseBuffer;
                tars::TC_Json::writeValue(_p, sJsonResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer);
                _rsp_len_ = sJsonResponseBuffer.size();
            }
            else
            {
                tars::TarsOutputStream<tars::BufferWriterVector> _os;
                _os.write(_ret, 0);

                current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer());
                _rsp_len_ = _os.getLength();
            }
            if (current->isTraced())
            {
                string _trace_param_;
                int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_);
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTimeout", 0, _trace_param_, "");
            }

        }

        virtual tars::Int32 testTrans(tars::Int32 index,const std::string & s,std::string &r,tars::TarsCurrentPtr current) = 0;
        static void async_response_testTrans(tars::TarsCurrentPtr current, tars::Int32 _ret, const std::string &r)
        {
            size_t _rsp_len_ = 0;
            if (current->getRequestVersion() == TUPVERSION )
            {
                UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                tarsAttr.setVersion(current->getRequestVersion());
                tarsAttr.put("", _ret);
                tarsAttr.put("tars_ret", _ret);
                tarsAttr.put("r", r);

                vector<char> sTupResponseBuffer;
                tarsAttr.encode(sTupResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sTupResponseBuffer);
                _rsp_len_ = sTupResponseBuffer.size();
            }
            else if (current->getRequestVersion() == JSONVERSION)
            {
                tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                _p->value["r"] = tars::JsonOutput::writeJson(r);
                _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                vector<char> sJsonResponseBuffer;
                tars::TC_Json::writeValue(_p, sJsonResponseBuffer);
                current->sendResponse(tars::TARSSERVERSUCCESS, sJsonResponseBuffer);
                _rsp_len_ = sJsonResponseBuffer.size();
            }
            else
            {
                tars::TarsOutputStream<tars::BufferWriterVector> _os;
                _os.write(_ret, 0);

                _os.write(r, 3);

                current->sendResponse(tars::TARSSERVERSUCCESS, _os.getByteBuffer());
                _rsp_len_ = _os.getLength();
            }
            if (current->isTraced())
            {
                string _trace_param_;
                int _trace_param_flag_ = ServantProxyThreadData::needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, current->getTraceKey(), _rsp_len_);
                if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                {
                    tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                    _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                    _p_->value["r"] = tars::JsonOutput::writeJson(r);
                    _trace_param_ = tars::TC_Json::writeValue(_p_);
                }
                else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                {
                    _trace_param_ = "{\"trace_param_over_max_len\":true}";
                }
                TARS_TRACE(current->getTraceKey(), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTrans", 0, _trace_param_, "");
            }

        }

    public:
        int onDispatch(tars::TarsCurrentPtr _current, vector<char> &_sResponseBuffer)
        {
            static ::std::string __Test__Hello_all[]=
            {
                "testConHash",
                "testCoro",
                "testDyeing",
                "testDyeingTrans",
                "testHello",
                "testPid",
                "testSyncTrans",
                "testTimeout",
                "testTrans"
            };

            pair<string*, string*> r = equal_range(__Test__Hello_all, __Test__Hello_all+9, _current->getFuncName());
            if(r.first == r.second) return tars::TARSSERVERNOFUNCERR;
            switch(r.first - __Test__Hello_all)
            {
                case 0:
                {
                    tars::TarsInputStream<tars::BufferReader> _is;
                    _is.setBuffer(_current->getRequestBuffer());
                    std::string sOut;
                    if (_current->getRequestVersion() == TUPVERSION)
                    {
                        UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                        tarsAttr.setVersion(_current->getRequestVersion());
                        tarsAttr.decode(_current->getRequestBuffer());
                        tarsAttr.getByDefault("sOut", sOut, sOut);
                    }
                    else if (_current->getRequestVersion() == JSONVERSION)
                    {
                        tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer()));
                        tars::JsonInput::readJson(sOut, _jsonPtr->value["sOut"], false);
                    }
                    else
                    {
                        _is.read(sOut, 1, false);
                    }
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testConHash", 0, _trace_param_, "");
                    }

                    tars::Int32 _ret = testConHash(sOut, _current);
                    if(_current->isResponse())
                    {
                        if (_current->getRequestVersion() == TUPVERSION)
                        {
                            UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                            tarsAttr.setVersion(_current->getRequestVersion());
                            tarsAttr.put("", _ret);
                            tarsAttr.put("tars_ret", _ret);
                            tarsAttr.put("sOut", sOut);
                            tarsAttr.encode(_sResponseBuffer);
                        }
                        else if (_current->getRequestVersion() == JSONVERSION)
                        {
                            tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                            _p->value["sOut"] = tars::JsonOutput::writeJson(sOut);
                            _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                            tars::TC_Json::writeValue(_p, _sResponseBuffer);
                        }
                        else
                        {
                            tars::TarsOutputStream<tars::BufferWriterVector> _os;
                            _os.write(_ret, 0);
                            _os.write(sOut, 1);
                            _os.swap(_sResponseBuffer);
                        }
                        if (pSptd && pSptd->_traceCall)
                        {
                            string _trace_param_;
                            int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size());
                            if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                            {
                                tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                                _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                                _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut);
                                _trace_param_ = tars::TC_Json::writeValue(_p_);
                            }
                            else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                            {
                                _trace_param_ = "{\"trace_param_over_max_len\":true}";
                            }
                            TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testConHash", 0, _trace_param_, "");
                        }

                    }
                    else if(pSptd && pSptd->_traceCall)
                    {
                        _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS));
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 1:
                {
                    tars::TarsInputStream<tars::BufferReader> _is;
                    _is.setBuffer(_current->getRequestBuffer());
                    std::string sIn;
                    std::string sOut;
                    if (_current->getRequestVersion() == TUPVERSION)
                    {
                        UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                        tarsAttr.setVersion(_current->getRequestVersion());
                        tarsAttr.decode(_current->getRequestBuffer());
                        tarsAttr.get("sIn", sIn);
                        tarsAttr.getByDefault("sOut", sOut, sOut);
                    }
                    else if (_current->getRequestVersion() == JSONVERSION)
                    {
                        tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer()));
                        tars::JsonInput::readJson(sIn, _jsonPtr->value["sIn"], true);
                        tars::JsonInput::readJson(sOut, _jsonPtr->value["sOut"], false);
                    }
                    else
                    {
                        _is.read(sIn, 1, true);
                        _is.read(sOut, 2, false);
                    }
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value["sIn"] = tars::JsonOutput::writeJson(sIn);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testCoro", 0, _trace_param_, "");
                    }

                    tars::Bool _ret = testCoro(sIn,sOut, _current);
                    if(_current->isResponse())
                    {
                        if (_current->getRequestVersion() == TUPVERSION)
                        {
                            UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                            tarsAttr.setVersion(_current->getRequestVersion());
                            tarsAttr.put("", _ret);
                            tarsAttr.put("tars_ret", _ret);
                            tarsAttr.put("sOut", sOut);
                            tarsAttr.encode(_sResponseBuffer);
                        }
                        else if (_current->getRequestVersion() == JSONVERSION)
                        {
                            tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                            _p->value["sOut"] = tars::JsonOutput::writeJson(sOut);
                            _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                            tars::TC_Json::writeValue(_p, _sResponseBuffer);
                        }
                        else
                        {
                            tars::TarsOutputStream<tars::BufferWriterVector> _os;
                            _os.write(_ret, 0);
                            _os.write(sOut, 2);
                            _os.swap(_sResponseBuffer);
                        }
                        if (pSptd && pSptd->_traceCall)
                        {
                            string _trace_param_;
                            int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size());
                            if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                            {
                                tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                                _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                                _p_->value["sOut"] = tars::JsonOutput::writeJson(sOut);
                                _trace_param_ = tars::TC_Json::writeValue(_p_);
                            }
                            else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                            {
                                _trace_param_ = "{\"trace_param_over_max_len\":true}";
                            }
                            TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testCoro", 0, _trace_param_, "");
                        }

                    }
                    else if(pSptd && pSptd->_traceCall)
                    {
                        _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS));
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 2:
                {
                    tars::TarsInputStream<tars::BufferReader> _is;
                    _is.setBuffer(_current->getRequestBuffer());
                    std::string strIn;
                    std::string strOut;
                    if (_current->getRequestVersion() == TUPVERSION)
                    {
                        UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                        tarsAttr.setVersion(_current->getRequestVersion());
                        tarsAttr.decode(_current->getRequestBuffer());
                        tarsAttr.get("strIn", strIn);
                        tarsAttr.getByDefault("strOut", strOut, strOut);
                    }
                    else if (_current->getRequestVersion() == JSONVERSION)
                    {
                        tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer()));
                        tars::JsonInput::readJson(strIn, _jsonPtr->value["strIn"], true);
                        tars::JsonInput::readJson(strOut, _jsonPtr->value["strOut"], false);
                    }
                    else
                    {
                        _is.read(strIn, 1, true);
                        _is.read(strOut, 2, false);
                    }
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value["strIn"] = tars::JsonOutput::writeJson(strIn);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeing", 0, _trace_param_, "");
                    }

                    tars::Int32 _ret = testDyeing(strIn,strOut, _current);
                    if(_current->isResponse())
                    {
                        if (_current->getRequestVersion() == TUPVERSION)
                        {
                            UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                            tarsAttr.setVersion(_current->getRequestVersion());
                            tarsAttr.put("", _ret);
                            tarsAttr.put("tars_ret", _ret);
                            tarsAttr.put("strOut", strOut);
                            tarsAttr.encode(_sResponseBuffer);
                        }
                        else if (_current->getRequestVersion() == JSONVERSION)
                        {
                            tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                            _p->value["strOut"] = tars::JsonOutput::writeJson(strOut);
                            _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                            tars::TC_Json::writeValue(_p, _sResponseBuffer);
                        }
                        else
                        {
                            tars::TarsOutputStream<tars::BufferWriterVector> _os;
                            _os.write(_ret, 0);
                            _os.write(strOut, 2);
                            _os.swap(_sResponseBuffer);
                        }
                        if (pSptd && pSptd->_traceCall)
                        {
                            string _trace_param_;
                            int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size());
                            if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                            {
                                tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                                _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                                _p_->value["strOut"] = tars::JsonOutput::writeJson(strOut);
                                _trace_param_ = tars::TC_Json::writeValue(_p_);
                            }
                            else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                            {
                                _trace_param_ = "{\"trace_param_over_max_len\":true}";
                            }
                            TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeing", 0, _trace_param_, "");
                        }

                    }
                    else if(pSptd && pSptd->_traceCall)
                    {
                        _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS));
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 3:
                {
                    tars::TarsInputStream<tars::BufferReader> _is;
                    _is.setBuffer(_current->getRequestBuffer());
                    if (_current->getRequestVersion() == TUPVERSION)
                    {
                        UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                        tarsAttr.setVersion(_current->getRequestVersion());
                        tarsAttr.decode(_current->getRequestBuffer());
                    }
                    else if (_current->getRequestVersion() == JSONVERSION)
                    {
                        tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer()));
                    }
                    else
                    {
                    }
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeingTrans", 0, _trace_param_, "");
                    }

                    tars::Int32 _ret = testDyeingTrans(_current);
                    if(_current->isResponse())
                    {
                        if (_current->getRequestVersion() == TUPVERSION)
                        {
                            UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                            tarsAttr.setVersion(_current->getRequestVersion());
                            tarsAttr.put("", _ret);
                            tarsAttr.put("tars_ret", _ret);
                            tarsAttr.encode(_sResponseBuffer);
                        }
                        else if (_current->getRequestVersion() == JSONVERSION)
                        {
                            tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                            _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                            tars::TC_Json::writeValue(_p, _sResponseBuffer);
                        }
                        else
                        {
                            tars::TarsOutputStream<tars::BufferWriterVector> _os;
                            _os.write(_ret, 0);
                            _os.swap(_sResponseBuffer);
                        }
                        if (pSptd && pSptd->_traceCall)
                        {
                            string _trace_param_;
                            int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size());
                            if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                            {
                                tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                                _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                                _trace_param_ = tars::TC_Json::writeValue(_p_);
                            }
                            else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                            {
                                _trace_param_ = "{\"trace_param_over_max_len\":true}";
                            }
                            TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testDyeingTrans", 0, _trace_param_, "");
                        }

                    }
                    else if(pSptd && pSptd->_traceCall)
                    {
                        _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS));
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 4:
                {
                    tars::TarsInputStream<tars::BufferReader> _is;
                    _is.setBuffer(_current->getRequestBuffer());
                    tars::Int32 index;
                    std::string s;
                    std::string r;
                    if (_current->getRequestVersion() == TUPVERSION)
                    {
                        UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                        tarsAttr.setVersion(_current->getRequestVersion());
                        tarsAttr.decode(_current->getRequestBuffer());
                        tarsAttr.get("index", index);
                        tarsAttr.get("s", s);
                        tarsAttr.getByDefault("r", r, r);
                    }
                    else if (_current->getRequestVersion() == JSONVERSION)
                    {
                        tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer()));
                        tars::JsonInput::readJson(index, _jsonPtr->value["index"], true);
                        tars::JsonInput::readJson(s, _jsonPtr->value["s"], true);
                        tars::JsonInput::readJson(r, _jsonPtr->value["r"], false);
                    }
                    else
                    {
                        _is.read(index, 1, true);
                        _is.read(s, 2, true);
                        _is.read(r, 3, false);
                    }
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value["index"] = tars::JsonOutput::writeJson(index);
                            _p_->value["s"] = tars::JsonOutput::writeJson(s);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testHello", 0, _trace_param_, "");
                    }

                    tars::Int32 _ret = testHello(index,s,r, _current);
                    if(_current->isResponse())
                    {
                        if (_current->getRequestVersion() == TUPVERSION)
                        {
                            UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                            tarsAttr.setVersion(_current->getRequestVersion());
                            tarsAttr.put("", _ret);
                            tarsAttr.put("tars_ret", _ret);
                            tarsAttr.put("r", r);
                            tarsAttr.encode(_sResponseBuffer);
                        }
                        else if (_current->getRequestVersion() == JSONVERSION)
                        {
                            tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                            _p->value["r"] = tars::JsonOutput::writeJson(r);
                            _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                            tars::TC_Json::writeValue(_p, _sResponseBuffer);
                        }
                        else
                        {
                            tars::TarsOutputStream<tars::BufferWriterVector> _os;
                            _os.write(_ret, 0);
                            _os.write(r, 3);
                            _os.swap(_sResponseBuffer);
                        }
                        if (pSptd && pSptd->_traceCall)
                        {
                            string _trace_param_;
                            int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size());
                            if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                            {
                                tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                                _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                                _p_->value["r"] = tars::JsonOutput::writeJson(r);
                                _trace_param_ = tars::TC_Json::writeValue(_p_);
                            }
                            else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                            {
                                _trace_param_ = "{\"trace_param_over_max_len\":true}";
                            }
                            TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testHello", 0, _trace_param_, "");
                        }

                    }
                    else if(pSptd && pSptd->_traceCall)
                    {
                        _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS));
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 5:
                {
                    tars::TarsInputStream<tars::BufferReader> _is;
                    _is.setBuffer(_current->getRequestBuffer());
                    std::string r;
                    if (_current->getRequestVersion() == TUPVERSION)
                    {
                        UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                        tarsAttr.setVersion(_current->getRequestVersion());
                        tarsAttr.decode(_current->getRequestBuffer());
                        tarsAttr.getByDefault("r", r, r);
                    }
                    else if (_current->getRequestVersion() == JSONVERSION)
                    {
                        tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer()));
                        tars::JsonInput::readJson(r, _jsonPtr->value["r"], false);
                    }
                    else
                    {
                        _is.read(r, 1, false);
                    }
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testPid", 0, _trace_param_, "");
                    }

                    tars::Int32 _ret = testPid(r, _current);
                    if(_current->isResponse())
                    {
                        if (_current->getRequestVersion() == TUPVERSION)
                        {
                            UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                            tarsAttr.setVersion(_current->getRequestVersion());
                            tarsAttr.put("", _ret);
                            tarsAttr.put("tars_ret", _ret);
                            tarsAttr.put("r", r);
                            tarsAttr.encode(_sResponseBuffer);
                        }
                        else if (_current->getRequestVersion() == JSONVERSION)
                        {
                            tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                            _p->value["r"] = tars::JsonOutput::writeJson(r);
                            _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                            tars::TC_Json::writeValue(_p, _sResponseBuffer);
                        }
                        else
                        {
                            tars::TarsOutputStream<tars::BufferWriterVector> _os;
                            _os.write(_ret, 0);
                            _os.write(r, 1);
                            _os.swap(_sResponseBuffer);
                        }
                        if (pSptd && pSptd->_traceCall)
                        {
                            string _trace_param_;
                            int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size());
                            if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                            {
                                tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                                _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                                _p_->value["r"] = tars::JsonOutput::writeJson(r);
                                _trace_param_ = tars::TC_Json::writeValue(_p_);
                            }
                            else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                            {
                                _trace_param_ = "{\"trace_param_over_max_len\":true}";
                            }
                            TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testPid", 0, _trace_param_, "");
                        }

                    }
                    else if(pSptd && pSptd->_traceCall)
                    {
                        _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS));
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 6:
                {
                    tars::TarsInputStream<tars::BufferReader> _is;
                    _is.setBuffer(_current->getRequestBuffer());
                    tars::Int32 index;
                    std::string s;
                    std::string r;
                    if (_current->getRequestVersion() == TUPVERSION)
                    {
                        UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                        tarsAttr.setVersion(_current->getRequestVersion());
                        tarsAttr.decode(_current->getRequestBuffer());
                        tarsAttr.get("index", index);
                        tarsAttr.get("s", s);
                        tarsAttr.getByDefault("r", r, r);
                    }
                    else if (_current->getRequestVersion() == JSONVERSION)
                    {
                        tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer()));
                        tars::JsonInput::readJson(index, _jsonPtr->value["index"], true);
                        tars::JsonInput::readJson(s, _jsonPtr->value["s"], true);
                        tars::JsonInput::readJson(r, _jsonPtr->value["r"], false);
                    }
                    else
                    {
                        _is.read(index, 1, true);
                        _is.read(s, 2, true);
                        _is.read(r, 3, false);
                    }
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value["index"] = tars::JsonOutput::writeJson(index);
                            _p_->value["s"] = tars::JsonOutput::writeJson(s);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testSyncTrans", 0, _trace_param_, "");
                    }

                    tars::Int32 _ret = testSyncTrans(index,s,r, _current);
                    if(_current->isResponse())
                    {
                        if (_current->getRequestVersion() == TUPVERSION)
                        {
                            UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                            tarsAttr.setVersion(_current->getRequestVersion());
                            tarsAttr.put("", _ret);
                            tarsAttr.put("tars_ret", _ret);
                            tarsAttr.put("r", r);
                            tarsAttr.encode(_sResponseBuffer);
                        }
                        else if (_current->getRequestVersion() == JSONVERSION)
                        {
                            tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                            _p->value["r"] = tars::JsonOutput::writeJson(r);
                            _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                            tars::TC_Json::writeValue(_p, _sResponseBuffer);
                        }
                        else
                        {
                            tars::TarsOutputStream<tars::BufferWriterVector> _os;
                            _os.write(_ret, 0);
                            _os.write(r, 3);
                            _os.swap(_sResponseBuffer);
                        }
                        if (pSptd && pSptd->_traceCall)
                        {
                            string _trace_param_;
                            int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size());
                            if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                            {
                                tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                                _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                                _p_->value["r"] = tars::JsonOutput::writeJson(r);
                                _trace_param_ = tars::TC_Json::writeValue(_p_);
                            }
                            else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                            {
                                _trace_param_ = "{\"trace_param_over_max_len\":true}";
                            }
                            TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testSyncTrans", 0, _trace_param_, "");
                        }

                    }
                    else if(pSptd && pSptd->_traceCall)
                    {
                        _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS));
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 7:
                {
                    tars::TarsInputStream<tars::BufferReader> _is;
                    _is.setBuffer(_current->getRequestBuffer());
                    tars::Int32 timeout;
                    if (_current->getRequestVersion() == TUPVERSION)
                    {
                        UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                        tarsAttr.setVersion(_current->getRequestVersion());
                        tarsAttr.decode(_current->getRequestBuffer());
                        tarsAttr.get("timeout", timeout);
                    }
                    else if (_current->getRequestVersion() == JSONVERSION)
                    {
                        tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer()));
                        tars::JsonInput::readJson(timeout, _jsonPtr->value["timeout"], true);
                    }
                    else
                    {
                        _is.read(timeout, 1, true);
                    }
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value["timeout"] = tars::JsonOutput::writeJson(timeout);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTimeout", 0, _trace_param_, "");
                    }

                    tars::Int32 _ret = testTimeout(timeout, _current);
                    if(_current->isResponse())
                    {
                        if (_current->getRequestVersion() == TUPVERSION)
                        {
                            UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                            tarsAttr.setVersion(_current->getRequestVersion());
                            tarsAttr.put("", _ret);
                            tarsAttr.put("tars_ret", _ret);
                            tarsAttr.encode(_sResponseBuffer);
                        }
                        else if (_current->getRequestVersion() == JSONVERSION)
                        {
                            tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                            _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                            tars::TC_Json::writeValue(_p, _sResponseBuffer);
                        }
                        else
                        {
                            tars::TarsOutputStream<tars::BufferWriterVector> _os;
                            _os.write(_ret, 0);
                            _os.swap(_sResponseBuffer);
                        }
                        if (pSptd && pSptd->_traceCall)
                        {
                            string _trace_param_;
                            int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size());
                            if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                            {
                                tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                                _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                                _trace_param_ = tars::TC_Json::writeValue(_p_);
                            }
                            else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                            {
                                _trace_param_ = "{\"trace_param_over_max_len\":true}";
                            }
                            TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTimeout", 0, _trace_param_, "");
                        }

                    }
                    else if(pSptd && pSptd->_traceCall)
                    {
                        _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS));
                    }

                    return tars::TARSSERVERSUCCESS;

                }
                case 8:
                {
                    tars::TarsInputStream<tars::BufferReader> _is;
                    _is.setBuffer(_current->getRequestBuffer());
                    tars::Int32 index;
                    std::string s;
                    std::string r;
                    if (_current->getRequestVersion() == TUPVERSION)
                    {
                        UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                        tarsAttr.setVersion(_current->getRequestVersion());
                        tarsAttr.decode(_current->getRequestBuffer());
                        tarsAttr.get("index", index);
                        tarsAttr.get("s", s);
                        tarsAttr.getByDefault("r", r, r);
                    }
                    else if (_current->getRequestVersion() == JSONVERSION)
                    {
                        tars::JsonValueObjPtr _jsonPtr = tars::JsonValueObjPtr::dynamicCast(tars::TC_Json::getValue(_current->getRequestBuffer()));
                        tars::JsonInput::readJson(index, _jsonPtr->value["index"], true);
                        tars::JsonInput::readJson(s, _jsonPtr->value["s"], true);
                        tars::JsonInput::readJson(r, _jsonPtr->value["r"], false);
                    }
                    else
                    {
                        _is.read(index, 1, true);
                        _is.read(s, 2, true);
                        _is.read(r, 3, false);
                    }
                    ServantProxyThreadData *pSptd = ServantProxyThreadData::getData();
                    if (pSptd && pSptd->_traceCall)
                    {
                        string _trace_param_;
                        int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SR, _is.size());
                        if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                        {
                            tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                            _p_->value["index"] = tars::JsonOutput::writeJson(index);
                            _p_->value["s"] = tars::JsonOutput::writeJson(s);
                            _trace_param_ = tars::TC_Json::writeValue(_p_);
                        }
                        else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                        {
                            _trace_param_ = "{\"trace_param_over_max_len\":true}";
                        }
                        TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SR), TRACE_ANNOTATION_SR, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTrans", 0, _trace_param_, "");
                    }

                    tars::Int32 _ret = testTrans(index,s,r, _current);
                    if(_current->isResponse())
                    {
                        if (_current->getRequestVersion() == TUPVERSION)
                        {
                            UniAttribute<tars::BufferWriterVector, tars::BufferReader>  tarsAttr;
                            tarsAttr.setVersion(_current->getRequestVersion());
                            tarsAttr.put("", _ret);
                            tarsAttr.put("tars_ret", _ret);
                            tarsAttr.put("r", r);
                            tarsAttr.encode(_sResponseBuffer);
                        }
                        else if (_current->getRequestVersion() == JSONVERSION)
                        {
                            tars::JsonValueObjPtr _p = new tars::JsonValueObj();
                            _p->value["r"] = tars::JsonOutput::writeJson(r);
                            _p->value["tars_ret"] = tars::JsonOutput::writeJson(_ret);
                            tars::TC_Json::writeValue(_p, _sResponseBuffer);
                        }
                        else
                        {
                            tars::TarsOutputStream<tars::BufferWriterVector> _os;
                            _os.write(_ret, 0);
                            _os.write(r, 3);
                            _os.swap(_sResponseBuffer);
                        }
                        if (pSptd && pSptd->_traceCall)
                        {
                            string _trace_param_;
                            int _trace_param_flag_ = pSptd->needTraceParam(ServantProxyThreadData::TraceContext::EST_SS, _sResponseBuffer.size());
                            if (ServantProxyThreadData::TraceContext::ENP_NORMAL == _trace_param_flag_)
                            {
                                tars::JsonValueObjPtr _p_ = new tars::JsonValueObj();
                                _p_->value[""] = tars::JsonOutput::writeJson(_ret);
                                _p_->value["r"] = tars::JsonOutput::writeJson(r);
                                _trace_param_ = tars::TC_Json::writeValue(_p_);
                            }
                            else if(ServantProxyThreadData::TraceContext::ENP_OVERMAXLEN == _trace_param_flag_)
                            {
                                _trace_param_ = "{\"trace_param_over_max_len\":true}";
                            }
                            TARS_TRACE(pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS), TRACE_ANNOTATION_SS, "", ServerConfig::Application + "." + ServerConfig::ServerName, "testTrans", 0, _trace_param_, "");
                        }

                    }
                    else if(pSptd && pSptd->_traceCall)
                    {
                        _current->setTrace(pSptd->_traceCall, pSptd->getTraceKey(ServantProxyThreadData::TraceContext::EST_SS));
                    }

                    return tars::TARSSERVERSUCCESS;

                }
            }
            return tars::TARSSERVERNOFUNCERR;
        }
    };


}



#endif