tars源码漫谈第42篇------tc_functor.h（仿函数）

最新推荐文章于 2024-05-23 09:51:14 发布
最新推荐文章于 2024-05-23 09:51:14 发布
阅读量5.1k 收藏 5
点赞数 2
分类专栏： s2: tarsC++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stpeace/article/details/79832706
版权

      仿函数好懂， 但tc_functor中涉及到的东西， 跟loki库差不多， 不好懂，来看下：

#ifndef __TC_FUNCTOR_H
#define __TC_FUNCTOR_H

#include <memory>
#include <iostream>
#include "util/tc_loki.h"

using namespace std;

namespace tars
{
///
/** 
 * @file tc_functor.h
 * @brief 通用仿函数类
 
 * 参考C++设计新思维, loki库的设计 
 * Functor对调用的封装,可以对以下几种调用封装:
 * C风格的函数调用
 * C风格的函数指针
 * C++风格的函数对象
 * 指向类成员函数的指针调用
 * 封装以后的调用形式可以变成两种:
 * A 仿函数对象调用方式, 即对上述的几种方式都可以在右侧添加一对圆括号,并在括号内部放一组合适的参数来调用
 * B 把整个调用过程封装一个函数对象, 随时调用, 调用的时候不用传入参数, 而在在对象建立时就传入了参数
 * C函数调用:
 *  void TestFunction3(const string &s, int i)
 *
 *  {
 *
 *       cout << "TestFunction3('" << s << "', '" << i << "')" << endl;
 *
 *  }
 *
 * TC_Functor<void, TL::TLMaker<const string&, int>::Result> cmd3(TestFunction3);
 * string s3("s3");
 * cmd3(s3, 10);
 * C函数调用用TC_FunctorWrapper封装:*
 *  TC_FunctorWrapper<TC_Functor<void, TL::TLMaker<const string&, int>::Result> > fwrapper3(cmd3, s3, 10);
 *  fwrapper3();
 * 说明:
 * void : 函数的返回值
 * C++函数对象调用:
 *  struct TestFunctor
 *  {
 *
 *      void operator()(const string &s, int i)
 *
 *      {
 *
 *          cout << "TestFunctor::operator(" << s << "," << i << ") called" << endl;
 *
 *      }
 *
 *  }
 *
 *  TestFunctor f;
 *
 *  TC_Functor<void, TL::TLMaker<const string&, int>::Result> cmd3(f);
 *
 *  string s3("s3");
 *
 *  cmd3(s3, 10);
 *
 * C++函数对象调用用TC_FunctorWrapper封装:
 *
 *  TC_FunctorWrapper<TC_Functor<void, TL::TLMaker<const string&, int>::Result> > fwrapper3(cmd3, s3, 10);
 *
 *  fwrapper3();
 *
 * 指向类成员函数的调用
 *  struct TestMember
 * {
 *     void mem3(const string &s, int i)
 *     {
 *          cout << "TestMember::mem3(" << s << "," << i << ") called" << endl;
 *     }
 *  }
 *  TC_Functor<void, TL::TLMaker<const string&, int>::Result> cmd3(&tm, &TestMember::mem3);
 * cmd3("a", 33);
 * 指向类成员函数的调用用TC_FunctorWrapper封装:
 *  TC_FunctorWrapper<TC_Functor<void, TL::TLMaker<const string&, int>::Result> > fwrapper3(cmd3, "a", 10);
 *  fwrapper3();
 * 注意所有的TC_FunctorWrapper的调用, 在具体调用的时候是不带参数的, 参数在构造的时候已经传进去了
 ///
 *
 * 对于C风格的函数调用, 同名称的函数通常只有一个, 如果有多个相同名称的函数
 *不同参数类型的函数, 则在构造TC_Functor的时候需要强制类型转换, 如下:
 *  void TestFunction1()
 *  {
 *      cout << "TestFunction1()" << endl;
 * }
 *  void TestFunction1(char c)
 *  {
 *      cout << "TestFunction1(" << c << ")" << endl;
 * }
 * typedef void (*TpFunc)();
 * TC_Functor<void> cmd1(static_cast<TpFunc>(TestFunction1));
 * cmd1();
 * typedef void (*TpFunc1)(char);
 * TC_Functor<void, TL::TLMaker<char>::Result>
 * cmd11(static_cast<TpFunc1>(TestFunction1)); cmd11('c');
 ///
 *
 * 对于类成员函数的指针调用, 同名称的函数通常只有一个, 如果有多个相同名称的函数
 * 不同参数类型的函数, 则在构造TC_Functor的时候需要强制类型转换, 如下:
 *  class TestMember
 *  {
 *  public:
 *      void mem1()
 *      {
 *          cout << "TestMember::mem1() called" << endl;
 *      }
 *      void mem1(char c)
 *      {
 *          cout << "TestMember::mem1('" << c << "') called" << endl;
 *      }
 *  };
 
 *  TestMember tm;
 
 *  typedef void (TestMember::*TpMem)();
 
 *  typedef void (TestMember::*TpMem1)(char);
 
 *  TC_Functor<void> cmd1(&tm, static_cast<TpMem>(&TestMember::mem1));
 *  cmd1();
 *
 *  typedef void (TestMember::*TpMem1)(char);
 
 * TC_Functor<void, TL::TLMaker<char>::Result> cmd11(&tm,
 
 * static_cast<TpMem1>(&TestMember::mem1)); cmd11('c');
 *
 * 具体示例请参见demo/test_tc_functor.cpp.
 */

template<typename R, class TList>
class TC_FunctorImp
{
public:
    virtual R operator()() = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template<typename R>
class TC_FunctorImp<R, TL::EmptyType>
{
public:
    virtual R operator()() = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template<typename R, typename P1>
class TC_FunctorImp<R, TL::TYPELIST_1(P1)>
{
public:
    virtual R operator()(typename TL::TypeTraits<P1>::ReferenceType p1) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template<typename R, typename P1, typename P2>
class TC_FunctorImp<R, TL::TYPELIST_2(P1, P2)>
{
public:
    virtual R operator()(typename TL::TypeTraits<P1>::ReferenceType p1,
                         typename TL::TypeTraits<P2>::ReferenceType p2) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template<typename R, typename P1, typename P2, typename P3>
class TC_FunctorImp<R, TL::TYPELIST_3(P1, P2, P3)>
{
public:
    virtual R operator()(typename TL::TypeTraits<P1>::ReferenceType p1,
                         typename TL::TypeTraits<P2>::ReferenceType p2,
                         typename TL::TypeTraits<P3>::ReferenceType p3) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template<typename R, typename P1, typename P2, typename P3, typename P4>
class TC_FunctorImp<R, TL::TYPELIST_4(P1, P2, P3, P4)>
{
public:
    virtual R operator()(typename TL::TypeTraits<P1>::ReferenceType p1,
                         typename TL::TypeTraits<P2>::ReferenceType p2,
                         typename TL::TypeTraits<P3>::ReferenceType p3,
                         typename TL::TypeTraits<P4>::ReferenceType p4) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5>
class TC_FunctorImp<R, TL::TYPELIST_5(P1, P2, P3, P4, P5)>
{
public:
    virtual R operator()(typename TL::TypeTraits<P1>::ReferenceType p1,
                         typename TL::TypeTraits<P2>::ReferenceType p2,
                         typename TL::TypeTraits<P3>::ReferenceType p3,
                         typename TL::TypeTraits<P4>::ReferenceType p4,
                         typename TL::TypeTraits<P5>::ReferenceType p5) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
class TC_FunctorImp<R, TL::TYPELIST_6(P1, P2, P3, P4, P5, P6)>
{
public:
    virtual R operator()(typename TL::TypeTraits<P1>::ReferenceType p1,
                         typename TL::TypeTraits<P2>::ReferenceType p2,
                         typename TL::TypeTraits<P3>::ReferenceType p3,
                         typename TL::TypeTraits<P4>::ReferenceType p4,
                         typename TL::TypeTraits<P5>::ReferenceType p5,
                         typename TL::TypeTraits<P6>::ReferenceType p6) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
class TC_FunctorImp<R, TL::TYPELIST_7(P1, P2, P3, P4, P5, P6, P7)>
{
public:
    virtual R operator()(typename TL::TypeTraits<P1>::ReferenceType p1,
                         typename TL::TypeTraits<P2>::ReferenceType p2,
                         typename TL::TypeTraits<P3>::ReferenceType p3,
                         typename TL::TypeTraits<P4>::ReferenceType p4,
                         typename TL::TypeTraits<P5>::ReferenceType p5,
                         typename TL::TypeTraits<P6>::ReferenceType p6,
                         typename TL::TypeTraits<P7>::ReferenceType p7) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
class TC_FunctorImp<R, TL::TYPELIST_8(P1, P2, P3, P4, P5, P6, P7, P8)>
{
public:
    virtual R operator()(typename TL::TypeTraits<P1>::ReferenceType p1,
                         typename TL::TypeTraits<P2>::ReferenceType p2,
                         typename TL::TypeTraits<P3>::ReferenceType p3,
                         typename TL::TypeTraits<P4>::ReferenceType p4,
                         typename TL::TypeTraits<P5>::ReferenceType p5,
                         typename TL::TypeTraits<P6>::ReferenceType p6,
                         typename TL::TypeTraits<P7>::ReferenceType p7,
                         typename TL::TypeTraits<P8>::ReferenceType p8) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
class TC_FunctorImp<R, TL::TYPELIST_9(P1, P2, P3, P4, P5, P6, P7, P8, P9)>
{
public:
    virtual R operator()(typename TL::TypeTraits<P1>::ReferenceType p1,
                         typename TL::TypeTraits<P2>::ReferenceType p2,
                         typename TL::TypeTraits<P3>::ReferenceType p3,
                         typename TL::TypeTraits<P4>::ReferenceType p4,
                         typename TL::TypeTraits<P5>::ReferenceType p5,
                         typename TL::TypeTraits<P6>::ReferenceType p6,
                         typename TL::TypeTraits<P7>::ReferenceType p7,
                         typename TL::TypeTraits<P8>::ReferenceType p8,
                         typename TL::TypeTraits<P9>::ReferenceType p9) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

template<typename R, typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
class TC_FunctorImp<R, TL::TYPELIST_10(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)>
{
public:
    virtual R operator()(typename TL::TypeTraits<P1>::ReferenceType p1,
                         typename TL::TypeTraits<P2>::ReferenceType p2,
                         typename TL::TypeTraits<P3>::ReferenceType p3,
                         typename TL::TypeTraits<P4>::ReferenceType p4,
                         typename TL::TypeTraits<P5>::ReferenceType p5,
                         typename TL::TypeTraits<P6>::ReferenceType p6,
                         typename TL::TypeTraits<P7>::ReferenceType p7,
                         typename TL::TypeTraits<P8>::ReferenceType p8,
                         typename TL::TypeTraits<P9>::ReferenceType p9,
                         typename TL::TypeTraits<P10>::ReferenceType p10) = 0;
    virtual TC_FunctorImp* clone() const = 0;
    virtual ~TC_FunctorImp() {};
};

/**
 * 封装对函数对象以及函数的调用
 */
template<class ParentFunctor, typename Fun>
class TC_FunctorHandler : public TC_FunctorImp<typename ParentFunctor::ResultType, typename ParentFunctor::ParamList>
{
public:
    typedef typename ParentFunctor::ResultType ResultType;

    TC_FunctorHandler(Fun fun) : _fun(fun)
    {

    }

    TC_FunctorHandler *clone() const
    {
        return new TC_FunctorHandler(*this);
    }

    ResultType operator()()
    { return _fun(); }

    ResultType operator()(typename ParentFunctor::Reference1 p1)
    { return _fun(p1); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2)
    { return _fun(p1, p2); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3)
    { return _fun(p1, p2, p3); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4)
    { return _fun(p1, p2, p3, p4); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4,
                        typename ParentFunctor::Reference5 p5)
    { return _fun(p1, p2, p3, p4, p5); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4,
                        typename ParentFunctor::Reference5 p5,
                        typename ParentFunctor::Reference6 p6)
    { return _fun(p1, p2, p3, p4, p5, p6); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4,
                        typename ParentFunctor::Reference5 p5,
                        typename ParentFunctor::Reference6 p6,
                        typename ParentFunctor::Reference7 p7)
    { return _fun(p1, p2, p3, p4, p5, p6, p7); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4,
                        typename ParentFunctor::Reference5 p5,
                        typename ParentFunctor::Reference6 p6,
                        typename ParentFunctor::Reference7 p7,
                        typename ParentFunctor::Reference8 p8)
    { return _fun(p1, p2, p3, p4, p5, p6, p7, p8); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4,
                        typename ParentFunctor::Reference5 p5,
                        typename ParentFunctor::Reference6 p6,
                        typename ParentFunctor::Reference7 p7,
                        typename ParentFunctor::Reference8 p8,
                        typename ParentFunctor::Reference9 p9)
    { return _fun(p1, p2, p3, p4, p5, p6, p7, p8, p9); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4,
                        typename ParentFunctor::Reference5 p5,
                        typename ParentFunctor::Reference6 p6,
                        typename ParentFunctor::Reference7 p7,
                        typename ParentFunctor::Reference8 p8,
                        typename ParentFunctor::Reference9 p9,
                        typename ParentFunctor::Reference10 p10)
    { return _fun(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }

private:
    Fun _fun;
};

template<class ParentFunctor, typename PointerToObj, typename PointerToMemFun>
/**
 * @brief 封装对成员函数的调用
 */
class TC_MemFunHandler
    : public TC_FunctorImp<typename ParentFunctor::ResultType, typename ParentFunctor::ParamList>
{
public:
    typedef typename ParentFunctor::ResultType ResultType;

    TC_MemFunHandler(const PointerToObj &pObj, PointerToMemFun pMemFn)
        : _pObj(pObj), _pMemFn(pMemFn)
    {
    }

    TC_MemFunHandler* clone() const
    {
        return new TC_MemFunHandler(*this);
    }

    ResultType operator()()
    { return (_pObj->*_pMemFn)(); }

    ResultType operator()(typename ParentFunctor::Reference1 p1)
    { return (_pObj->*_pMemFn)(p1); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2)
    { return (_pObj->*_pMemFn)(p1, p2); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3)
    { return (_pObj->*_pMemFn)(p1, p2, p3); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4)
    { return (_pObj->*_pMemFn)(p1, p2, p3, p4); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4,
                        typename ParentFunctor::Reference5 p5)
    { return (_pObj->*_pMemFn)(p1, p2, p3, p4, p5); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4,
                        typename ParentFunctor::Reference5 p5,
                        typename ParentFunctor::Reference6 p6)
    { return (_pObj->*_pMemFn)(p1, p2, p3, p4, p5, p6); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4,
                        typename ParentFunctor::Reference5 p5,
                        typename ParentFunctor::Reference6 p6,
                        typename ParentFunctor::Reference7 p7)
    { return (_pObj->*_pMemFn)(p1, p2, p3, p4, p5, p6, p7); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4,
                        typename ParentFunctor::Reference5 p5,
                        typename ParentFunctor::Reference6 p6,
                        typename ParentFunctor::Reference7 p7,
                        typename ParentFunctor::Reference8 p8)
    { return (_pObj->*_pMemFn)(p1, p2, p3, p4, p5, p6, p7, p8); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4,
                        typename ParentFunctor::Reference5 p5,
                        typename ParentFunctor::Reference6 p6,
                        typename ParentFunctor::Reference7 p7,
                        typename ParentFunctor::Reference8 p8,
                        typename ParentFunctor::Reference9 p9)
    { return (_pObj->*_pMemFn)(p1, p2, p3, p4, p5, p6, p7, p8, p9); }

    ResultType operator()(typename ParentFunctor::Reference1 p1,
                        typename ParentFunctor::Reference2 p2,
                        typename ParentFunctor::Reference3 p3,
                        typename ParentFunctor::Reference4 p4,
                        typename ParentFunctor::Reference5 p5,
                        typename ParentFunctor::Reference6 p6,
                        typename ParentFunctor::Reference7 p7,
                        typename ParentFunctor::Reference8 p8,
                        typename ParentFunctor::Reference9 p9,
                        typename ParentFunctor::Reference10 p10)
    { return (_pObj->*_pMemFn)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); }

private:
    PointerToObj    _pObj;
    PointerToMemFun _pMemFn;
};

template<class ParentFunctor>
class TC_FunctorWrapper;


template<typename R, class TList = TL::NullType>
/**
 * @brief 函数对象类, 可以封装对: 函数对象, 函数, 成员函数 
 *        的调用
 */
class TC_Functor
{
public:
    typedef R     ResultType;
    typedef TList ParamList;

    /**定义封装类型*/
    typedef TC_FunctorWrapper<TC_Functor<R, TList> > wrapper_type;

    /**定义类型列表中每个参数的原类型*/
    typedef typename TL::TypeTraits<typename TL::TypeAtNonStrict<TList, 0, TL::EmptyType>::Result>::ParameterType Param1;
    typedef typename TL::TypeTraits<typename TL::TypeAtNonStrict<TList, 1, TL::EmptyType>::Result>::ParameterType Param2;
    typedef typename TL::TypeTraits<typename TL::TypeAtNonStrict<TList, 2, TL::EmptyType>::Result>::ParameterType Param3;
    typedef typename TL::TypeTraits<typename TL::TypeAtNonStrict<TList, 3, TL::EmptyType>::Result>::ParameterType Param4;
    typedef typename TL::TypeTraits<typename TL::TypeAtNonStrict<TList, 4, TL::EmptyType>::Result>::ParameterType Param5;
    typedef typename TL::TypeTraits<typename TL::TypeAtNonStrict<TList, 5, TL::EmptyType>::Result>::ParameterType Param6;
    typedef typename TL::TypeTraits<typename TL::TypeAtNonStrict<TList, 6, TL::EmptyType>::Result>::ParameterType Param7;
    typedef typename TL::TypeTraits<typename TL::TypeAtNonStrict<TList, 7, TL::EmptyType>::Result>::ParameterType Param8;
    typedef typename TL::TypeTraits<typename TL::TypeAtNonStrict<TList, 8, TL::EmptyType>::Result>::ParameterType Param9;
    typedef typename TL::TypeTraits<typename TL::TypeAtNonStrict<TList, 9, TL::EmptyType>::Result>::ParameterType Param10;

    /**定义类型列表中每个参数的引用类型*/
    typedef typename TL::TypeTraits<Param1>::ReferenceType Reference1;
    typedef typename TL::TypeTraits<Param2>::ReferenceType Reference2;
    typedef typename TL::TypeTraits<Param3>::ReferenceType Reference3;
    typedef typename TL::TypeTraits<Param4>::ReferenceType Reference4;
    typedef typename TL::TypeTraits<Param5>::ReferenceType Reference5;
    typedef typename TL::TypeTraits<Param6>::ReferenceType Reference6;
    typedef typename TL::TypeTraits<Param7>::ReferenceType Reference7;
    typedef typename TL::TypeTraits<Param8>::ReferenceType Reference8;
    typedef typename TL::TypeTraits<Param9>::ReferenceType Reference9;
    typedef typename TL::TypeTraits<Param10>::ReferenceType Reference10;

public:
    TC_Functor()
    {
    }

    TC_Functor(const TC_Functor &functor)
    : _spImpl(functor._spImpl->clone())
    {
    }

    TC_Functor& operator=(const TC_Functor &functor)
    {
        if(this != &functor)
        {
            _spImpl = std::auto_ptr<Impl>(functor._spImpl->clone());
        }

        return (*this);
    }

    template<class Fun>
    TC_Functor(Fun fun)
    : _spImpl(new TC_FunctorHandler<TC_Functor, Fun>(fun))
    {
    }

    template<typename PointerToObj, typename PointerToMemFun>
    TC_Functor(const PointerToObj &pObj, PointerToMemFun pMemFn)
    : _spImpl(new TC_MemFunHandler<TC_Functor, PointerToObj, PointerToMemFun>(pObj, pMemFn))
    {
    }

    // 判断是否已经设置了functor
    // 可以这样使用if(functor)
    operator bool() const
    {
        return _spImpl.get() ? true : false;
    }

    R operator()()
    {
        return (*_spImpl)();
    }

    R operator()(Reference1 p1)
    {
        return (*_spImpl)(p1);
    }

    R operator()(Reference1 p1, Reference2 p2)
    {
        return (*_spImpl)(p1, p2);
    }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3)
    {
        return (*_spImpl)(p1, p2, p3);
    }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4)
    {
        return (*_spImpl)(p1, p2, p3, p4);
    }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4, Reference5 p5)
    {
        return (*_spImpl)(p1, p2, p3, p4, p5);
    }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4, Reference5 p5, Reference6 p6)
    {
        return (*_spImpl)(p1, p2, p3, p4, p5, p6);
    }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4, Reference5 p5, Reference6 p6, Reference7 p7)
    {
        return (*_spImpl)(p1, p2, p3, p4, p5, p6, p7);
    }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4, Reference5 p5, Reference6 p6, Reference7 p7, Reference8 p8)
    {
        return (*_spImpl)(p1, p2, p3, p4, p5, p6, p7, p8);
    }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4, Reference5 p5, Reference6 p6, Reference7 p7, Reference8 p8, Reference9 p9)
    {
        return (*_spImpl)(p1, p2, p3, p4, p5, p6, p7, p8, p9);
    }

    R operator()(Reference1 p1, Reference2 p2, Reference3 p3, Reference4 p4, Reference5 p5, Reference6 p6, Reference7 p7, Reference8 p8, Reference9 p9, Reference10 p10)
    {
        return (*_spImpl)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
    }


private:
    template<class ParentFunctor>
    friend class TC_FunctorWrapper;

    typedef TC_FunctorImp<R, TList> Impl;

    std::auto_ptr<Impl>     _spImpl;
};

/**
 * @brief wapper基类
 */
class TC_FunctorWrapperInterface
{
public:
    virtual void operator()() = 0;
    virtual ~TC_FunctorWrapperInterface(){}
};

template<class ParentFunctor>

/**
 * @brief 对TC_Functor进行封装, 可以让TC_Functor做到事后被调用
 */
class TC_FunctorWrapper : public TC_FunctorWrapperInterface
{
public:
    typedef typename ParentFunctor::ResultType R;
    typedef typename ParentFunctor::ParamList  TList;

    /**
     * @brief 拷贝构造
     * @param fw
     */
    TC_FunctorWrapper(const TC_FunctorWrapper &fw)
    : _spImpl(fw._spImpl->clone())
    , _p1(fw._p1)
    , _p2(fw._p2)
    , _p3(fw._p3)
    , _p4(fw._p4)
    , _p5(fw._p5)
    , _p6(fw._p6)
    , _p7(fw._p7)
    , _p8(fw._p8)
    , _p9(fw._p9)
    , _p10(fw._p10)
    {
    }

    /**
     * @brief 构造函数
     * @param tf
     */
    TC_FunctorWrapper(ParentFunctor &tf)
    : _spImpl(tf._spImpl->clone())
    {
    }

    /**
     * @brief 一个参数调用的构造函数
     * @param tf
     * @param p1
     */
    TC_FunctorWrapper(ParentFunctor &tf,
                  typename ParentFunctor::Reference1 p1)
    : _spImpl(tf._spImpl->clone()), _p1(p1)
    {
    }

    /**
     * @brief 两个参数调用的构造函数
     * @param tf
     * @param p1
     * @param p2
     */
    TC_FunctorWrapper(ParentFunctor &tf,
                  typename ParentFunctor::Reference1 p1,
                  typename ParentFunctor::Reference2 p2)
    : _spImpl(tf._spImpl->clone()), _p1(p1), _p2(p2)
    {
    }

    /**
     * @brief 三个参数调用的构造函数
     * @param tf
     * @param p1
     * @param p2
     * @param p3
     */
    TC_FunctorWrapper(ParentFunctor &tf,
                  typename ParentFunctor::Reference1 p1,
                  typename ParentFunctor::Reference2 p2,
                  typename ParentFunctor::Reference3 p3)
    : _spImpl(tf._spImpl->clone()), _p1(p1), _p2(p2), _p3(p3)
    {
    }

    /**
     * @brief 四个参数调用的构造函数
     * @param tf
     * @param p1
     * @param p2
     * @param p3
     * @param p4
     */
    TC_FunctorWrapper(ParentFunctor &tf,
                                            typename ParentFunctor::Reference1 p1,
                                            typename ParentFunctor::Reference2 p2,
                                            typename ParentFunctor::Reference3 p3,
                                            typename ParentFunctor::Reference4 p4)
    : _spImpl(tf._spImpl->clone()), _p1(p1), _p2(p2), _p3(p3), _p4(p4)
    {
    }

    /**
     * @brief 五个参数调用的构造函数
     * @param tf
     * @param p1
     * @param p2
     * @param p3
     * @param p4
     * @param p5
     */
    TC_FunctorWrapper(ParentFunctor &tf,
                                            typename ParentFunctor::Reference1 p1,
                                            typename ParentFunctor::Reference2 p2,
                                            typename ParentFunctor::Reference3 p3,
                                            typename ParentFunctor::Reference4 p4,
                                            typename ParentFunctor::Reference5 p5)
    : _spImpl(tf._spImpl->clone()), _p1(p1), _p2(p2), _p3(p3), _p4(p4), _p5(p5)
    {
    }

    /**
     * @brief 六个参数调用的构造函数
     * @param tf
     * @param p1
     * @param p2
     * @param p3
     * @param p4
     * @param p5
     * @param p6
     */
    TC_FunctorWrapper(ParentFunctor &tf,
                                            typename ParentFunctor::Reference1 p1,
                                            typename ParentFunctor::Reference2 p2,
                                            typename ParentFunctor::Reference3 p3,
                                            typename ParentFunctor::Reference4 p4,
                                            typename ParentFunctor::Reference5 p5,
                                            typename ParentFunctor::Reference6 p6)
    : _spImpl(tf._spImpl->clone()), _p1(p1), _p2(p2), _p3(p3), _p4(p4), _p5(p5), _p6(p6)
    {
    }

    /**
     * @brief 七个参数调用的构造函数
     * @param tf
     * @param p1
     * @param p2
     * @param p3
     * @param p4
     * @param p5
     * @param p6
     * @param p7
     */
    TC_FunctorWrapper(ParentFunctor &tf,
                                            typename ParentFunctor::Reference1 p1,
                                            typename ParentFunctor::Reference2 p2,
                                            typename ParentFunctor::Reference3 p3,
                                            typename ParentFunctor::Reference4 p4,
                                            typename ParentFunctor::Reference5 p5,
                                            typename ParentFunctor::Reference6 p6,
                                            typename ParentFunctor::Reference7 p7)
    : _spImpl(tf._spImpl->clone()), _p1(p1), _p2(p2), _p3(p3), _p4(p4), _p5(p5), _p6(p6), _p7(p7)
    {
    }

    /**
     * @brief 八个参数调用的构造函数
     * @param tf
     * @param p1
     * @param p2
     * @param p3
     * @param p4
     * @param p5
     * @param p6
     * @param p7
     * @param p8
     */
    TC_FunctorWrapper(ParentFunctor &tf,
                                            typename ParentFunctor::Reference1 p1,
                                            typename ParentFunctor::Reference2 p2,
                                            typename ParentFunctor::Reference3 p3,
                                            typename ParentFunctor::Reference4 p4,
                                            typename ParentFunctor::Reference5 p5,
                                            typename ParentFunctor::Reference6 p6,
                                            typename ParentFunctor::Reference7 p7,
                                            typename ParentFunctor::Reference8 p8)
    : _spImpl(tf._spImpl->clone()), _p1(p1), _p2(p2), _p3(p3), _p4(p4), _p5(p5), _p6(p6), _p7(p7), _p8(p8)
    {
    }

    /**
     * @brief 九个参数调用的构造函数
     * @param tf
     * @param p1
     * @param p2
     * @param p3
     * @param p4
     * @param p5
     * @param p6
     * @param p7
     * @param p8
     * @param p9
     */
    TC_FunctorWrapper(ParentFunctor &tf,
                                            typename ParentFunctor::Reference1 p1,
                                            typename ParentFunctor::Reference2 p2,
                                            typename ParentFunctor::Reference3 p3,
                                            typename ParentFunctor::Reference4 p4,
                                            typename ParentFunctor::Reference5 p5,
                                            typename ParentFunctor::Reference6 p6,
                                            typename ParentFunctor::Reference7 p7,
                                            typename ParentFunctor::Reference8 p8,
                                            typename ParentFunctor::Reference9 p9)
    : _spImpl(tf._spImpl->clone()), _p1(p1), _p2(p2), _p3(p3), _p4(p4), _p5(p5), _p6(p6), _p7(p7), _p8(p8), _p9(p9)
    {
    }

    /**
     * @brief 十个参数调用的构造函数
     * @param tf
     * @param p1
     * @param p2
     * @param p3
     * @param p4
     * @param p5
     * @param p6
     * @param p7
     * @param p8
     * @param p9
     * @param p10
     */
    TC_FunctorWrapper(ParentFunctor &tf,
                                            typename ParentFunctor::Reference1 p1,
                                            typename ParentFunctor::Reference2 p2,
                                            typename ParentFunctor::Reference3 p3,
                                            typename ParentFunctor::Reference4 p4,
                                            typename ParentFunctor::Reference5 p5,
                                            typename ParentFunctor::Reference6 p6,
                                            typename ParentFunctor::Reference7 p7,
                                            typename ParentFunctor::Reference8 p8,
                                            typename ParentFunctor::Reference9 p9,
                                            typename ParentFunctor::Reference10 p10)
    : _spImpl(tf._spImpl->clone()), _p1(p1), _p2(p2), _p3(p3), _p4(p4), _p5(p5), _p6(p6), _p7(p7), _p8(p8), _p9(p9), _p10(p10)
    {
    }

    /**
     * @brief 具体调用
     * @param tf
     * @param p1
     */
    virtual R operator()()
    {
        return todo(TL::Int2Type<TL::Length<TList>::value>());
    }

    virtual ~TC_FunctorWrapper(){ }

protected:
    /**
     * @brief 赋值函数不定义, 只声明
     * @param fw
     *
     * @return TC_FunctorWrapper&
     */
    TC_FunctorWrapper& operator=(const TC_FunctorWrapper &fw);

    R todo(TL::Int2Type<0>)
    {
        return (*_spImpl)();
    }

    R todo(TL::Int2Type<1>)
    {
        return (*_spImpl)(_p1);
    }

    R todo(TL::Int2Type<2>)
    {
        return (*_spImpl)(_p1, _p2);
    }

    R todo(TL::Int2Type<3>)
    {
        return (*_spImpl)(_p1, _p2, _p3);
    }

    R todo(TL::Int2Type<4>)
    {
        return (*_spImpl)(_p1, _p2, _p3, _p4);
    }

    R todo(TL::Int2Type<5>)
    {
        return (*_spImpl)(_p1, _p2, _p3, _p4, _p5);
    }

    R todo(TL::Int2Type<6>)
    {
        return (*_spImpl)(_p1, _p2, _p3, _p4, _p5, _p6);
    }

    R todo(TL::Int2Type<7>)
    {
        return (*_spImpl)(_p1, _p2, _p3, _p4, _p5, _p6, _p7);
    }

    R todo(TL::Int2Type<8>)
    {
        return (*_spImpl)(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8);
    }

    R todo(TL::Int2Type<9>)
    {
        return (*_spImpl)(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9);
    }

    R todo(TL::Int2Type<10>)
    {
        return (*_spImpl)(_p1, _p2, _p3, _p4, _p5, _p6, _p7, _p8, _p9, _p10);
    }

protected:
    typedef TC_FunctorImp<R, TList> Impl;

    std::auto_ptr<Impl>             _spImpl;

    /*
    typename TL::TypeTraits<typename ParentFunctor::Param1>::ReferenceTypeEx   _p1;
    typename TL::TypeTraits<typename ParentFunctor::Param2>::ReferenceTypeEx   _p2;
    typename TL::TypeTraits<typename ParentFunctor::Param3>::ReferenceTypeEx   _p3;
    typename TL::TypeTraits<typename ParentFunctor::Param4>::ReferenceTypeEx   _p4;
    typename TL::TypeTraits<typename ParentFunctor::Param5>::ReferenceTypeEx   _p5;
    typename TL::TypeTraits<typename ParentFunctor::Param6>::ReferenceTypeEx   _p6;
    typename TL::TypeTraits<typename ParentFunctor::Param7>::ReferenceTypeEx   _p7;
    typename TL::TypeTraits<typename ParentFunctor::Param8>::ReferenceTypeEx   _p8;
    typename TL::TypeTraits<typename ParentFunctor::Param9>::ReferenceTypeEx   _p9;
    typename TL::TypeTraits<typename ParentFunctor::Param10>::ReferenceTypeEx  _p10;
    */

    typename TL::TypeTraits<typename ParentFunctor::Param1>::ParameterType   _p1;
    typename TL::TypeTraits<typename ParentFunctor::Param2>::ParameterType   _p2;
    typename TL::TypeTraits<typename ParentFunctor::Param3>::ParameterType   _p3;
    typename TL::TypeTraits<typename ParentFunctor::Param4>::ParameterType   _p4;
    typename TL::TypeTraits<typename ParentFunctor::Param5>::ParameterType   _p5;
    typename TL::TypeTraits<typename ParentFunctor::Param6>::ParameterType   _p6;
    typename TL::TypeTraits<typename ParentFunctor::Param7>::ParameterType   _p7;
    typename TL::TypeTraits<typename ParentFunctor::Param8>::ParameterType   _p8;
    typename TL::TypeTraits<typename ParentFunctor::Param9>::ParameterType   _p9;
    typename TL::TypeTraits<typename ParentFunctor::Param10>::ParameterType  _p10;
};

}

#endif

      先忽略。

 

涛歌依旧
关注
专栏目录
tars源码漫谈第37篇------tc_file_mutex.h/tc_file_mutex.cpp（文件互斥锁）
认知 行动 坚持
04-06 4970
      文件锁的概念， 应该听说过， 本文我们来看看tc_file_mutex中对文件锁的封装， 有点文件互斥锁的感觉。 其中的TC_FileMutex只能用于进程间加锁,  来看看源码：/** * Tencent is pleased to support the open source community by making Tars available. * * Copyright...
tars源码漫谈第33篇------tc_pack.h/tc_pack.cpp(序列化和反序列化)
认知 行动 坚持
04-05 5207
       看tc_pack这个名字就知道， 这可能涉及到打包操作， 进去看一下， 果然。 其实， 就是序列化和反序列化。       源码中充斥了对 &lt;&lt;和&gt;&gt;的重载， 让使用者感觉到比较爽， 我们来看看如何使用： bool b = false; char c = 'x'; short si = 100; i...
TarsJava:Java语言框架rpc源代码实现-java source code
03-25
Tars Java-RPC库和框架 该项目是Tars RPC框架Java语言的源代码。 主页： 中文版： 环境依赖性 JDK1.8以上 Maven 3.5或以上 Docker的TarsFramework部署 本指南使用Docker来完成Tars的部署。[Macos，Linux] **在Docker中启动TarsFramework ** docker pull tarscloud/framework:latest docker pull tarscloud/tars-node:latest docker pull mysql:5.6 docker network create -d bridge --subnet=172.25.0.0/16 --gateway=172.25.0.1 tars docker run -d \ --net=tars \ -e MYSQL_ROOT_P
Tars-Java客户端源码分析
vivo互联网技术
05-08 426
Tars是基于名字服务使用Tars协议的RPC开发框架，配套一个服务治理平台，帮助开发者快速构建一个分布式应用。其中Tars客户端支持C++，Java，Go等语言，方便各个语言程序互相进行高性能RPC调用。本文将介绍Tars-Java客户端设计理念，方便开发人员理解其设计原理。
腾讯 tars java_腾讯TARS开源团队郑苏波：腾讯微服务开发框架的源码剖析
weixin_36225248的博客
02-28 400
郑苏波：大家下午好！我是腾讯微服务的郑苏波。先做一个框架的介绍，Tars是一个支持多语言内嵌服务治理功能的框槛，能跟DevOps比较好的协同开发。这个框架四大特点：一是对用户透明实现，让业务可以聚焦自己的逻辑，不需要关心这个框架提供了哪些能力。二是支持RPC的调用方式，使业务能快速开发。三是高性能的实现。四是丰富的扩展能力，适应不同业务场景。下面我们会以一个比较简单的语言，NodeJS这个语言在T...
Tars快速入门（JAVA）学习笔记
MCC_MCC_MCC的博客
11-18 3607
1.Tars快速入门（Java） https://tars.tencent.com/base/help/TARS_quick_start_Java.html 2.按照文档中的安装指南安装（需要结合官方文档） https://github.com/Tencent/Tars/blob/master/Install.md (1)安装依赖的环境 （1）主要安装 yum install gl...
推荐开源项目：Tars框架Java实现
最新发布
gitblog_00068的博客
05-23 383
推荐开源项目：Tars框架Java实现 TarsJava Java language framework rpc source code implementation 项目地址: https://gitcode.com/gh_mirrors/ta/TarsJava...
Tars.js菜单和文档-Node.js开发
05-27
Tars.js随着Internet的发展，越来越多的服务不仅可以由单个节点（或单一语言）提供，而且可以由多语言分布式协作开发（例如访问层由Tars.js组成）进行。随着Internet的发展，越来越多的服务不仅可以由单个节点（或...
Tars源码分析---TC_EpollServer
Swartz2015的专栏
06-15 1805
前言 架构 IO_Thread Pool Handler Pool Adapter 总结 前言 这个系列的文章主要分析腾讯的开源RPC框架Tars。Tars除了提供RPC服务之外，还配套了一整套的运营管理平台。它同时支持C++，java等多种编程语言。本系列主要是分析tars的cpp部分实现，涉及的版本是github上最近release的1.40版。主要是在源...
tars-cli：TARS的CLI
02-03
TARS-CLI — TARS标记生成器命令行界面。 使用TARS开发标记的主要问题是每次为每个项目安装所有npm依赖项。 结果，每个项目占用200MB以上的内存。 为了简化项目的初始化和使用TARS的工作，建立了TARS-CLI。 所有...
TARS:一流的自动语音识别系统（TARS）
05-14
塔斯 一流的自动语音识别系统（TARS） 安装 按照说明作为原始wavenet实施。 但是，不要安装scikits.audiolab ，而应使用支持Python 3.x的soundfile 另外，从源代码编译Libsndfile或从brew安装时，请确保启用Flac支持 MacOS ：（） brew install libsndfile --with-lame --with-flac --with-libvorbis brew link --overwrite libsndfile 另外，安装了ffmpeg 重要档案 preprocess.py-由其他人编写，用于从声音文件创建lmfcc并将这些标签存储在资产/数据/预处理文件夹中Conf.py-参数和字母映射 train.py-用于训练的主文件，运行此文件以获取可以在tensorboard model中绘制的日志文件.py-为模型
Tars | 第2篇 TarsJava SpingBoot启动与负载均衡源码初探
多氯环己烷的博客
07-29 478
TarsJava SpingBoot启动与负载均衡源码初探前言1. Tars客户端启动@EnableTarsServer2. Communicator通信器3. 客户端的负载均衡调用器LoadBalance最后 前言 通过源码分析可以得出这样一个负载均衡的源码结构图（基于TarsJava SpringBoot）： @EnableTarsServer注解：表明这是一个Tars服务； @Import(TarsServerConfiguration.class)：引入Tars服务相关配置文件； Commu
Tars-Java网络编程源码分析
BASK2312的博客
03-21 233
Tars是腾讯开源的支持多语言的高性能RPC框架，起源于腾讯内部2008年至今一直使用的统一应用框架TAF（Total Application Framework），目前支持C++、Java、PHP、Nodejs、Go语言。该框架为用户提供了涉及到开发、运维、以及测试的一整套解决方案，帮助一个产品或者服务快速开发、部署、测试、上线。
java接入tars_Tars环境搭建之路
weixin_31234793的博客
02-25 442
搭建Tars可以通过两种方式：docker，linux原生方式一：docker方式安装环境这个方式相对来说简单多了docker本质上是通过linux容器概念来实现复制软件集成环境，达到完美同步原始软件的需求，基于docker的操作手册可以查看https://www.cnblogs.com/xiaoping1993/p/10602859.html1.配置docker环境如果你是window10，可以...
腾讯 tars java_腾讯 Tars 基础框架手动搭建——填掉官方 Guide 的坑
weixin_36336411的博客
02-28 774
背景Tars 简介腾讯 Tars 是腾讯内部使用的 TAF(Tencent Application Framework)的对外开源版，去掉了许多冗杂多余的部分。该框架集开发、运维、微服务、RPC 等为一体。对程序员而言，这就是一个能够快速搭建整个微服务体系的开发框架。这个框架支持基于 C++、Node.js、PHP、Java 等语言开发，最新版本已经支持后台开发语言新贵——Go。系列文章安装任务T...
Tars | 第1篇 Win10下Docker部署TarsJava(SpringBoot)全过程及踩坑记录
多氯环己烷的博客
07-12 1061
TarsJava部署入门前言1. 相关环境版本：坑点一：VMware与Win10 Docker冲突坑点二：TarsJava(SpringBoot)依赖文件缺失2. Docker安装：3. Tars部署：4. 代码处理：5. 接口调试：最后 前言 受限于网上资源有限，加上小白一枚，笔者在Tars入门部署时踩了不少的坑，不过最终还是部署成功了，便想记录一下其中过程与心得； Win10下Docker部署TarsJava(SpringBoot)主要分为这几部分：Docker部署，Tars部署以及测试，说难不难但
腾讯 tars java_TarsJava - Tars-Spring 使用说明 - 《Tars 1.8 使用手册》 - 书栈网 · BookStack...
weixin_39920403的博客
02-28 320
Tars-Spring 使用说明功能说明Tars支持使用Spring配置servant，使用此功能需要依赖tars-spring.jar包，以及spring 4及以上版本。你可以将你的servant作为一个Spring bean，你可以自由的使用Spring的功能最后只需要通过Tars提供的标签告知Tars哪些些bean是servant即可。依赖配置使用此功能需要添加依赖jar包，在pom.xml...
python 微服务框架_PHP微服务框架：腾讯高性能RPC开发框架Tars实现服务治理(微服务)...
weixin_39573136的博客
12-06 414
1. 介绍Tars是基于名字服务使用Tars协议的高性能RPC开发框架，同时配套一体化的服务治理平台，帮助个人或者企业快速的以微服务的方式构建自己稳定可靠的分布式应用。Tars是将腾讯内部使用的微服务架构TAF(Total Application Framework)多年的实践成果总结而成的开源项目。Tars这个名字来自星际穿越电影人机器人Tars，电影中Tars有着非常友好的交互方式，任何初次接...
tars源码漫谈第32篇------tc_parsepara.h/tc_parsepara.cpp（http式参数的parse）
认知 行动 坚持
04-05 5025
最近要开发一个需求， 涉及到http参数的处理， 我居然还自己去写string到map和map到string的转换， 当看到tc_parsepara后， 深感痛心， 原来， tars的基础库早就实现了这些功能， 来看一下：/** * Tencent is pleased to support the open source community by making Tars availa...
TARS-PHP：打造高性能RPC框架的实践
3. TARS-协议：TARS框架使用私有的二进制协议，支持扩展其他协议，协议设计包括请求和响应两部分，包含协议版本、请求/返回码以及二进制数据包，确保了通信的稳定性和安全性。 4. TARS-微服务：TARS-PHP支持微服务...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值