tars源码漫谈第1篇------tc_loki.h (牛逼哄哄的loki库)

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

        loki库是C++模板大牛Andrei写的， 里面大量运用模板的特性， 而tc_loki.h借用了loki库的部分代码， 形成了一个基本的文件tc_loki.h， 来看看：

#ifndef __TC_TYPETRAITS_H
#define __TC_TYPETRAITS_H

#include <memory>

namespace tars
{
/
// 说明: loki            
/

namespace TL
{
    //只声明, 不定义的类, 作为TYPELIST的末端类型
    class NullType;

    //空类型
    struct EmptyType { };

    /**
     * 数值到类型的映射
     */
    template<int v>
    struct Int2Type
    {
       enum { value = v };
    };

    /**
     * 类型到类型的映射
     */
    template<typename T>
    struct Type2Type
    {
        typedef T OriginalType;
    };

    ///
    // 以下是TypeList的定义(目前只支持10个参数)
    /**
     * 定义类型链表
    */
    template<typename Head, typename Tail>
    struct TypeList
    {
        typedef Head H;
        typedef Tail T;
    };

    #define TYPELIST_1(T1) TypeList<T1, TL::NullType>
    #define TYPELIST_2(T1, T2) TypeList<T1, TL::TYPELIST_1(T2)>
    #define TYPELIST_3(T1, T2, T3) TypeList<T1, TL::TYPELIST_2(T2, T3)>
    #define TYPELIST_4(T1, T2, T3, T4) TypeList<T1, TL::TYPELIST_3(T2, T3, T4)>
    #define TYPELIST_5(T1, T2, T3, T4, T5) TypeList<T1, TL::TYPELIST_4(T2, T3, T4, T5)>
    #define TYPELIST_6(T1, T2, T3, T4, T5, T6) TypeList<T1, TL::TYPELIST_5(T2, T3, T4, T5, T6)>
    #define TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) TypeList<T1, TL::TYPELIST_6(T2, T3, T4, T5, T6, T7)>
    #define TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) TypeList<T1, TL::TYPELIST_7(T2, T3, T4, T5, T6, T7, T8)>
    #define TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) TypeList<T1, TL::TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9)>
    #define TYPELIST_10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) TypeList<T1, TL::TYPELIST_9(T2, T3, T4, T5, T6, T7, T8, T9, T10)>
    #define TYPELIST_11(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) TypeList<T1, TL::TYPELIST_10(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)>
    #define TYPELIST_12(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) TypeList<T1, TL::TYPELIST_11(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)>
    #define TYPELIST_13(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) TypeList<T1, TL::TYPELIST_12(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)>
    #define TYPELIST_14(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14) TypeList<T1, TL::TYPELIST_13(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)>
    #define TYPELIST_15(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15) TypeList<T1, TL::TYPELIST_14(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)>
    #define TYPELIST_16(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16) TypeList<T1, TL::TYPELIST_15(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)>
    #define TYPELIST_17(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17) TypeList<T1, TL::TYPELIST_16(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)>
    #define TYPELIST_18(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18) TypeList<T1, TL::TYPELIST_17(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)>
    #define TYPELIST_19(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19) TypeList<T1, TL::TYPELIST_18(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)>
    #define TYPELIST_20(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) TypeList<T1, TL::TYPELIST_19(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)>


    //
    // 以下定义TypeList的编译期的操作函数(通过偏特化实现)
    /**
     * Length: 取TypeList的长度
     */
    template<class TList> struct Length;
    template<> struct Length<NullType>
    {
        enum { value = 0 };
    };
    template<class Head, class Tail> struct Length<TypeList<Head, Tail> >
    {
        enum { value = 1 + Length<Tail>::value };
    };

    /**
     * TypeAt, 取链表在i位置上的类型
     */
    template<class TList, unsigned int i> struct TypeAt;
    template<class Head, class Tail> struct TypeAt<TypeList<Head, Tail>, 0>
    {
        typedef Head Result;
    };
    template<class Head, class Tail, unsigned int i> struct TypeAt<TypeList<Head, Tail>, i>
    {
        typedef typename TypeAt<Tail, i-1>::Result Result;
    };

    /**
     * TypeAt, 取链表在i位置上的类型, i超出了返回, 则返回DefaultType
     */
    template<class TList, unsigned int index, typename DefaultType = NullType> struct TypeAtNonStrict
    {
        typedef DefaultType Result;
    };
    template <class Head, class Tail, typename DefaultType> struct TypeAtNonStrict<TypeList<Head, Tail>, 0, DefaultType>
    {
        typedef Head Result;
    };
    template <class Head, class Tail, unsigned int i, typename DefaultType> struct TypeAtNonStrict<TypeList<Head, Tail>, i, DefaultType>
    {
        typedef typename TypeAtNonStrict<Tail, i - 1, DefaultType>::Result Result;
    };

    /**
     * 取链表上类型为T的序号, 没有则返回-1
     */
    template<class TList, class T> struct IndexOf;
    template<class T> struct IndexOf<NullType, T>
    {
        enum { value = -1 };
    };
    template<class Tail, class T> struct IndexOf<TypeList<T,Tail>, T>
    {
        enum { value = 0 };
    };
    template<class Head, class Tail, class T> struct IndexOf<TypeList<Head, Tail>, T>
    {
    private:
        enum { temp = IndexOf<Tail, T>::value };
    public:
        enum { value = temp == -1 ? -1 : 1 + temp };
    };

    /**
     * Append, 添加到链表尾部
     */
    template<class TList, class T> struct Append;
    template<> struct Append<NullType, NullType>
    {
        typedef NullType Result;
    };
    template<class T> struct Append<NullType,T>
    {
        typedef TYPELIST_1(T) Result;
    };
    template<class Head, class Tail> struct Append<NullType, TypeList<Head, Tail> >
    {
        typedef TypeList<Head, Tail> Result;
    };
    template<class Head, class Tail, class T> struct Append<TypeList<Head, Tail>, T>
    {
        typedef TypeList<Head, typename Append<Tail, T>::Result> Result;
    };

    /**
     * Erase 删除
     */
    template<class TList, class T> struct Erase;
    template<class T> struct Erase<NullType, T>
    {
        typedef NullType Result;
    };
    template<class T, class Tail> struct Erase<TypeList<T, Tail>, T>
    {
        typedef Tail Result;
    };
    template<class Head, class Tail, class T> struct Erase<TypeList<Head, Tail>, T>
    {
        typedef TypeList<Head, typename Erase<Tail, T>::Result> Result;
    };

    /**
     * EraseAll 删除
     */
    template<class TList, class T> struct EraseAll;
    template<class T> struct EraseAll<NullType, T>
    {
        typedef NullType Result;
    };
    template<class T, class Tail> struct EraseAll<TypeList<T, Tail>, T>
    {
        typedef typename EraseAll<Tail, T>::Result Result;
    };
    template<class Head, class Tail, class T> struct EraseAll<TypeList<Head, Tail>, T>
    {
        typedef TypeList<Head, typename EraseAll<Tail, T>::Result> Result;
    };

    /**
     * 生成TypeList类型
     */
    template<class T1=NullType,  class T2=NullType,  class T3=NullType,  class T4=NullType,  class T5=NullType,
             class T6=NullType,  class T7=NullType,  class T8=NullType,  class T9=NullType,  class T10=NullType,
             class T11=NullType, class T12=NullType, class T13=NullType, class T14=NullType, class T15=NullType,
             class T16=NullType, class T17=NullType, class T18=NullType, class T19=NullType, class T20=NullType>
    struct TLMaker
    {
    private:
        typedef TYPELIST_20(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
                            T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) TmpList;
    public:
        typedef typename EraseAll<TmpList, NullType>::Result Result;
    };

    /
    //判断类型T是否可以转换成类型U(参考了wbl库, 直接采用loki, 编译时会有警告
    //关键:如果能够转换, 则接收U的函数, 也能够接收T
    template<class T, class U>
    class Conversion
    {
    protected:
        typedef char YES;
        struct NO {char dummy[2];};
        struct any_conversion
        {
            template <typename P> any_conversion(const volatile P&);
            template <typename P> any_conversion(P&);
        };

        template <typename P> struct conversion_checker
        {
            static NO  _m_check(any_conversion ...);
            static YES _m_check(P, int);
        };    

        static T _m_from;
    public:
        enum
        {
            //是否可以转换(如果Test(makeT())匹配到了static Small Test(U), 则可以转换)
            exists      = (sizeof(conversion_checker<U>::_m_check(_m_from, 0)) == sizeof(YES)),
            //是否可以双向转换
            exists2Way  = exists && Conversion<U, T>::exists,
            //是否相同类型
            sameType    = false
        };
    };

    //偏特化来确定sameType
    template<class T>
    class Conversion<T, T>
    {
    public:
        enum
        {
            exists      = true,
            exists2Way  = true,
            sameType    = true
        };
    };

    //判断两个类是否可以继承
    //关键:子类指针可以转换成父类指针, 且不是void*类型
    //相同类型, SUPERSUBCLASS判断为true
    #define SUPERSUBCLASS(T, U) (TL::Conversion<const U*, const T*>::exists && !TL::Conversion<const T*, const void*>::sameType)
    //相同类型, SUPERSUBCLASS_STRICT判断为false
    #define SUPERSUBCLASS_STRICT(T, U) (SUPERSUBCLASS(T, U) && !TL::Conversion<const T, const U>::sameType)

    ///
    // 类型选择器
    template<bool flag, typename U, typename V>
    struct TypeSelect
    {
        typedef U Result;
    };

    template<typename U, typename V>
    struct TypeSelect<false, U, V>
    {
        typedef V Result;
    };

    ///
    /**
     * 类型萃取器, copy至Loki库
     */
    template<typename T>
    class TypeTraits
    {
    private:

        ///
        //提取引用的原始类型(即去掉引用类型)
        template<class U>
        struct ReferenceTraits
        {
            enum { result = false };
            typedef U Result;
        };

        template<class U>
        struct ReferenceTraits<U&>
        {
            enum { result = true };
            typedef U Result;
        };

        ///
        //指针类型
        template<class U>
        struct PointerTraits
        {
            enum { result = false };
            typedef TL::NullType Result;
        };

        template<class U>
        struct PointerTraits<U*>
        {
            enum { result = true };
            typedef U Result;
        };

        template<class U>
        struct PointerTraits<U*&>
        {
            enum { result = true };
            typedef U Result;
        };

        ///
        //成员函数指针, gcc下面支持有问题, 屏蔽之
        template<typename U>
        struct PointerToMemberTraits
        {
            enum { result = false };
        };

        template<class U, class V>
        struct PointerToMemberTraits<U V::*>
        {
            enum { result = true };
        };

        template<class U, class V>
        struct PointerToMemberTraits<U V::*&>
        {
            enum { result = true };
        };

        ///
        // const
        template<typename U>
        struct UnConstTraits
        {
            enum { result = false };
            typedef U Result;
        };
        template<typename U>
        struct UnConstTraits<const U>
        {
            enum { result = true };
            typedef U Result;
        };
        template<typename U>
        struct UnConstTraits<const U&>
        {
            enum { result = true };
            typedef U& Result;
        };

        ///
        // volatile
        template<typename U>
        struct UnVolatileTraits
        {
            enum { result = false };
            typedef U Result;
        };
        template<typename U>
        struct UnVolatileTraits<volatile U>
        {
            enum { result = true };
            typedef U Result;
        };
        template<typename U>
        struct UnVolatileTraits<volatile U&>
        {
            enum { result = true };
            typedef U& Result;
        };
    public:
        //T是否是指针类型
        enum { isPointer        = PointerTraits<T>::result };
        //T是否是引用类型
        enum { isReference         = ReferenceTraits<T>::result };
        //T是否指向成员函数的指针
        enum { isMemberPointer     = PointerToMemberTraits<T>::result };

        //T是否是Const类型
        enum { isConst          = UnConstTraits<T>::result };
        //T是否是Volatile类型
        enum { isVolatile       = UnVolatileTraits<T>::result };

        //如果T是指针类型,则获取T的原类型, 即去掉指针类型
        typedef typename PointerTraits<T>::Result             PointeeType;
        //如果T是引用类型,则获取T的原类型, 即去掉引用类型
        typedef typename ReferenceTraits<T>::Result         ReferencedType;
        //如果T是Const类型,则获取T的原类型, 即去掉Const类型
        typedef typename UnConstTraits<T>::Result           NonConstType;
        //如果T是volatile类型,则获取T的原类型, 即去掉volatile类型
        typedef typename UnVolatileTraits<T>::Result        NonVolatileType;
        //去掉const volatile类型
        typedef typename UnVolatileTraits<typename UnConstTraits<T>::Result>::Result UnqualifiedType;

    public:

        //
        //
        typedef TL::TLMaker<unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long>::Result UnsignedInts;
        typedef TL::TLMaker<signed char, short, int, long, long long>::Result SignedInts;
        typedef TL::TLMaker<bool, char, wchar_t>::Result OtherInts;
        typedef TL::TLMaker<float, double, long double>::Result Floats;
        typedef TL::TYPELIST_2(TL::EmptyType, TL::NullType) NullTypes;

        //无符号整形
        enum { isStdUnsignedInt = TL::IndexOf<UnsignedInts, T>::value >= 0 };
        //有符号整形
        enum { isStdSignedInt     = TL::IndexOf<SignedInts, T>::value >= 0 };
        //整形
        enum { isStdInt         = isStdUnsignedInt || isStdSignedInt || TL::IndexOf<OtherInts, T>::value >= 0 };
        //浮点类型
        enum { isStdFloat         = TL::IndexOf<Floats, T>::value >= 0 };
        //数值类型
        enum { isStdArith         = isStdInt || isStdFloat };
        //基础类型(包括void)
        enum { isStdFundamental    = isStdArith || TL::IndexOf<TL::TYPELIST_1(void), T>::value >= 0};
        //空类型
        enum { isNullType       = TL::IndexOf<NullTypes, T>::value >= 0 };
        //简单类型
        enum { isBaseType       = isStdArith || isPointer || isMemberPointer };

        //对于复杂类型, 获取数据的引用类型, 即加上引用类型
        typedef typename TypeSelect<isBaseType, T, ReferencedType&>::Result ReferenceType;

        //对于复杂类型且非空类型, 获取数据的引用类型, 即加上引用类型
        //typedef typename TypeSelect<isBaseType || isNullType, T, ReferencedType&>::Result ReferenceTypeEx;

        //获取数据的原类型, 消除引用的引用这种情况
        typedef typename TypeSelect<!isReference, T, ReferencedType&>::Result ParameterType;
    };

    
    //下面的使用开始展示TypeList的威力, 用于自动生成class

    //散乱的继承体系
    template<class TList, template <class> class Unit>
    class ScatterHierarchy;

    /*
    namespace p
    {
        //注释copy至loki库
        // The following type helps to overcome subtle flaw in the original
        // implementation of GenScatterHierarchy.
        // The flaw is revealed when the input type list of GenScatterHierarchy
        // contains more then tars element of the same type (e.g. LOKI_TYPELIST_2(int, int)).
        // In this case GenScatterHierarchy will contain multiple bases of the same
        // type and some of them will not be reachable (per 10.3).
        // For example before the fix the first element of Tuple<LOKI_TYPELIST_2(int, int)>
        // is not reachable in any way!
        template<class, class>
        struct ScatterHierarchyTag;
    }

    template<class T1, class T2, template <class> class Unit>
    class ScatterHierarchy<TypeList<T1, T2>, Unit> : public ScatterHierarchy<p::ScatterHierarchyTag<T1, T2>, Unit>
                                                   , public ScatterHierarchy<T2, Unit>
    {
    public:
        typedef TypeList<T1, T2> TList;
        typedef ScatterHierarchy<p::ScatterHierarchyTag<T1, T2>, Unit> LeftBase;
        typedef ScatterHierarchy<T2, Unit> RightBase;

        template<typename T> struct Rebind
        {
            typedef Unit<T> Result;
        };
    };

    // In the middle *unique* class that resolve possible ambiguity
    template <class T1, class T2, template <class> class Unit>
    class ScatterHierarchy<p::ScatterHierarchyTag<T1, T2>, Unit>
        : public ScatterHierarchy<T1, Unit>
    {
    };
    */

    //具现化继承体系
    template <class T1, class T2, template <class> class Unit>
    class ScatterHierarchy<TypeList<T1, T2>, Unit>
        : public ScatterHierarchy<T1, Unit>
        , public ScatterHierarchy<T2, Unit>
    {
    public:
        typedef TypeList<T1, T2> TList;
        typedef ScatterHierarchy<T1, Unit> LeftBase;
        typedef ScatterHierarchy<T2, Unit> RightBase;
        template <typename T> struct Rebind
        {
            typedef Unit<T> Result;
        };
    };

    template<class AtomicType, template <class> class Unit>
    class ScatterHierarchy : public Unit<AtomicType>
    {
    public:
        typedef Unit<AtomicType> LeftBase;

        template<typename T> struct Rebind
        {
            typedef Unit<T> Result;
        };
    };

    template<template <class> class Unit>
    class ScatterHierarchy<NullType, Unit>
    {
    public:
        template<typename T> struct Rebind
        {
            typedef Unit<T> Result;
        };
    };

    /
    //构建继承体系后, 采用下面的函数获取继承体系中某个类

    template<class T, class H>
    struct FieldHelperByType
    {
        typedef typename H::template Rebind<T>::Result ResultType;
        static ResultType& dochange(H &obj)
        {
            return static_cast<ResultType&>(obj);
        }
    };
    template<class T, class H>
    struct FieldHelperByType<T, const H>
    {
        typedef const typename H::template Rebind<T>::Result ResultType;
        static ResultType& dochange(const H &obj)
        {
            return (ResultType&)obj;
        }
    };

    //直接按照类型获取, 如果有两个相同的类型, 则编译不过
    template<class T, class H>
    typename FieldHelperByType<T, H>::ResultType& field(H &obj)
    {
        return FieldHelperByType<T, H>::dochange(obj);
    }

    /
    // 根据索引获取字段
    //定义Tuple, 默认的数据操作器(Unit)
    template<typename T>
    struct TupleUnit
    {
        T _value;
        operator T&()               { return _value; }
        operator const T&() const   { return _value; }
    };

    template<class TList>
    struct Tuple : public ScatterHierarchy<TList, TupleUnit>
    {
    };

    //定义FieldHelperByIndex
    template<class H, unsigned int i> struct FieldHelperByIndex;

    //特化版本的FieldHelperByIndex, 推导出最后一个元素
    template<class H>
    struct FieldHelperByIndex<H, 0>
    {
        typedef typename H::TList::H ElementType;
        typedef typename H::template Rebind<ElementType>::Result UnitType;

        enum
        {
            isTuple = Conversion<UnitType, TupleUnit<ElementType> >::sameType,
            isConst = TypeTraits<H>::isConst
        };

        typedef const typename H::LeftBase ConstLeftBase;
        typedef typename TypeSelect<isConst, ConstLeftBase, typename H::LeftBase>::Result LeftBase;
        typedef typename TypeSelect<isTuple, ElementType, UnitType>::Result UnqualifiedResultType;
        typedef typename TypeSelect<isConst, const UnqualifiedResultType, UnqualifiedResultType>::Result ResultType;

        static ResultType &dochange(H& obj)
        {
            LeftBase &leftBase = obj;
            return (ResultType&)leftBase;
        }
    };

    //根据索引获取FieldHelper
    template<class H, unsigned int i>
    struct FieldHelperByIndex
    {
        typedef typename TypeAt<typename H::TList, i>::Result ElementType;
        typedef typename H::template Rebind<ElementType>::Result UnitType;

        enum
        {
            isTuple = Conversion<UnitType, TupleUnit<ElementType> >::sameType,
            isConst = TypeTraits<H>::isConst
        };

        typedef const typename H::RightBase ConstRightBase;
        typedef typename TypeSelect<isConst, ConstRightBase, typename H::RightBase>::Result RightBase;
        typedef typename TypeSelect<isTuple, ElementType, UnitType>::Result UnqualifiedResultType;
        typedef typename TypeSelect<isConst, const UnqualifiedResultType, UnqualifiedResultType>::Result ResultType;

        static ResultType &dochange(H& obj)
        {
            RightBase &rightBase = obj;
            return FieldHelperByIndex<RightBase, i-1>::dochange(rightBase);
        }
    };

    //定义按照索引获取
    template<unsigned int i, class H>
    typename FieldHelperByIndex<H, i>::ResultType &field(H& obj)
    {
        return FieldHelperByIndex<H, i>::dochange(obj);
    }
}

}
#endif

       是不是有一种看天书的感觉， 确实如此。

       也行, 姑且把它当成和STL类似的基础库， 别纠结于它。

       

 

涛歌依旧
关注
专栏目录
Tars源码学习
CWX
04-14 1245
Tars源码学习文章的规划
tars源码漫谈第37篇------tc_file_mutex.h/tc_file_mutex.cpp（文件互斥锁）
认知 行动 坚持
04-06 4965
      文件锁的概念， 应该听说过， 本文我们来看看tc_file_mutex中对文件锁的封装， 有点文件互斥锁的感觉。 其中的TC_FileMutex只能用于进程间加锁,  来看看源码：/** * Tencent is pleased to support the open source community by making Tars available. * * Copyright...
Loki源码
04-07
《C++设计新思维》中的Loki库源码。该库充分的运用了C++中template的特性，并实现了常用的设计模式，是一个非常好的学习和开发用的库。
【设计模式】--C++设计模式类库 Loki介绍与用法
_Witch__的专栏
05-29 4629
http://www.usidcbbs.com/simple/?t2428.html http://book.douban.com/subject/1119904/ C++设计模式类库 Loki介绍与用法 Loki是由Andrei编写的一个与《Modern C++ Design》（C++设计新思维）一书配套发行的C++代码库。 它不仅把C++模板的功能发挥到了极致，而且把类似设
推荐使用Loki：简单易用的分布式追踪系统
最新发布
gitblog_00024的博客
06-21 432
推荐使用Loki：简单易用的分布式追踪系统 项目地址:https://gitcode.com/weaveworks-experiments/loki 在复杂微服务架构中，了解请求的全链路执行过程变得尤为重要。为此，我们推荐一款名为Loki的开源分布式追踪系统，它借鉴了Zipkin和Prometheus的优点，提供了一种全新的跟踪解决方案。 1. 项目介绍 Loki是一个基于Pull机制的分布式追踪...
Loki库源码(泛型模式C++库)
09-14
Loki is the name of a C++ software library written by Andrei Alexandrescu as part of his book Modern C++ Design. 　　The library makes extensive use of C++ template metaprogramming and implements several commonly used tools: typelist, functor, singleton, smart pointer, object factory, visitor and multimethods. 　　Originally the library was only compatible with two of the most standard conforming C++ compilers (CodeWarrior and Comeau C/C++): later efforts have made it usable with a wide array of compilers (including older Visual C++ 6.0, Borland C++ Builder 6.0, and GCC). Compiler vendors used Loki as a compatibility benchmark, further increasing the number of compliant compilers. 　　Maintenance and further development of Loki has been continued through an open-source community led by Peter Kümmel and Richard Sposato as a Sourceforge project.Ongoing contributions by many people have improved the overallrobustness and functionality of the library. Loki is not tied to thebook anymore as it already has a lot of new components (e.g. -StrongPtr, Printf, and Scopeguard). Loki inspired similar tools andfunctionality now also present in the [1][2]Boost library collection. [1] http://en.wikipedia.org/wiki/Loki_(C%2B%2B) [2] http://loki-lib.sourceforge.net/
tars源码漫谈第10篇------tc_base64.h/tc_base64.cpp（base64基本操作）
认知 行动 坚持
04-01 5169
与md5/sha的哈希不一样, base64是一种编解码方法， 可逆。 有很多在线工具计算base64, 可以实际感受一下。 为什么命名为base64呢？ 有兴趣的话， 可以思考一下。 看了一下源码， 不好看。 但代码原创者值得尊重， 后面的人， 不过是抄抄抄，用用用而已， 也该如此。 感受一下源码：/** * Tencent is pleased to support t...
tars源码漫谈第33篇------tc_pack.h/tc_pack.cpp(序列化和反序列化)
认知 行动 坚持
04-05 5192
       看tc_pack这个名字就知道， 这可能涉及到打包操作， 进去看一下， 果然。 其实， 就是序列化和反序列化。       源码中充斥了对 &lt;&lt;和&gt;&gt;的重载， 让使用者感觉到比较爽， 我们来看看如何使用： bool b = false; char c = 'x'; short si = 100; i...
Tars源码分析---TC_EpollServer
Swartz2015的专栏
06-15 1785
前言 架构 IO_Thread Pool Handler Pool Adapter 总结 前言 这个系列的文章主要分析腾讯的开源RPC框架Tars。Tars除了提供RPC服务之外，还配套了一整套的运营管理平台。它同时支持C++，java等多种编程语言。本系列主要是分析tars的cpp部分实现，涉及的版本是github上最近release的1.40版。主要是在源...
Tars.js菜单和文档-Node.js开发
05-27
Tars.js随着Internet的发展，越来越多的服务不仅可以由单个节点（或单一语言）提供，而且可以由多语言分布式协作开发（例如访问层由Tars.js组成）进行。随着Internet的发展，越来越多的服务不仅可以由单个节点（或...
tars-utils:前端常用工具方法库 :rocket:
08-03
tars-utils 是一个前端常用工具方法库，整理了在前端项目里高频使用的 utils 方法，所有方法均以简洁易读的 es2015+ 语法实现。 欢迎直接引用本库，也欢迎查看并选用本项目里个别方法的实现。 文档 TODO 示例 const ...
LOKI库文件
02-14
大师之作。美德作品。
loki 库 源码 策略设计模式
12-21
loki库采用了高强度的c++模板设计，能充分的体现基于策略的设计模式。
递归之美 － Loki库TypeList源码剖析
hoping的专栏
07-23 3538
 递归之美 － Loki库TypeList源码剖析邓 辉　TypeList概观提起List，想必大家都不会陌生，它是一个元素的集合，并且提供了一些对该集合进行操作的方法，比如：计算集合中元素的个数、向集合中添加元素、获取给定索引处的元素等。我们所熟知的List中的元素一般都是实例化后的值，相关的操作也都是在运行期间进行的。本文将要剖析的List和上述的List在某种
《Modern C++ Design》Loki库源码读解随想 (转)
csd3176的博客
12-13 191
《Modern C++ Design》Loki库源码读解随想 (转)[@more@]《Modern C++ Design》Loki库源码读解随想 大牛Andrei Alexandrescu的《Modern C++ Design...
tars源码漫谈第12篇------tc_option.h/tc_option.cpp（命令行解析）
认知 行动 坚持
04-01 5305
在执行二进制程序的时候， 往往需要给定输入参数， 那么， 二进制程序对应的代码该如何解析这些参数呢？ 比如：./a.out --name1=value1 --name2=value2 tc_option就是专门干这个的， 下次就不要自己去解析了。 看看源码：/** * Tencent is pleased to support the open source comm...
tars framework 源码解读(一) 总述
weixin_30333885的博客
09-25 803
tars framework源码 其实分两块。 一块是tarscpp 这块的代码跟外面的tarscpp貌似是一毛一样的。这块代码实现了一个服务的基础lib 一块是framework基础服务代码实现。这些服务撑起来整个tars系统的框架功能。直接用Introduction.zh.md中的图来说明一下吧。 整体架构的拓扑图主要分为2个部分：服务节点与公共框架节点。服务节...
Tars源码分析----Application
Swartz2015的专栏
06-17 3345
前言 前言
tars-源码分析-服务端
lowkey956的博客
01-27 2481
server端代码分析 项目地址-作者lowkey 主要类简介 Application 我们实现的helloServer需要继承自这个类。主要承载配置的解析、epollser的初始化、消息的处理和分发、servant的创建和管理。 其中最主要的两个成员： EpollServer、ServantHelperManager TC_EpollServer 接收新的连接 负载所有io 消息分发到servant ServantHelperManager helloServer初始化的时候会通
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值