path: root/library/cpp/lwtrace/signature.h

#pragma once 
 
#include "preprocessor.h"

#include <library/cpp/lwtrace/protos/lwtrace.pb.h>

#include <util/generic/cast.h>
#include <util/generic/string.h>
#include <util/generic/typetraits.h> 
#include <util/string/builder.h>
#include <util/string/cast.h> 
#include <util/string/printf.h> 
 
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_enum_reflection.h>

#include <library/cpp/lwtrace/protos/lwtrace.pb.h>

#include <type_traits>

namespace NLWTrace { 
    // Class to hold parameter values parsed from trace query predicate operators 
    template <class T> 
    struct TParamConv { 
        static T FromString(const TString& text) { 
            return ::FromString<T>(text); 
        } 
        static TString ToString(const T& param) { 
            return ::ToString(param); 
        } 
    }; 
 
    template <> 
    struct TParamConv<TString const*> { 
        static TString FromString(const TString& text) { 
            return text; 
        } 
        static TString ToString(TString const* param) { 
            return TString(*param); 
        } 
    }; 
 
    template <> 
    struct TParamConv<ui8> { 
        static ui8 FromString(const TString& text) { 
            return (ui8)::FromString<ui16>(text); 
        } 
        static TString ToString(ui8 param) { 
            return ::ToString((ui16)param); 
        } 
    }; 
 
    template <> 
    struct TParamConv<i8> { 
        static i8 FromString(const TString& text) { 
            return (i8)::FromString<i16>(text); 
        } 
        static TString ToString(i8 param) { 
            return ::ToString((i16)param); 
        } 
    }; 
 
    template <> 
    struct TParamConv<double> { 
        static double FromString(const TString& text) { 
            return ::FromString<double>(text); 
        } 
        static TString ToString(double param) { 
            return Sprintf("%.6lf", param); 
        } 
    }; 
 
    // Fake parameter type used as a placeholder for not used parameters (above the number of defined params for a specific probe) 
    class TNil { 
    }; 
 
    // Struct that holds and handles a value of parameter of any supported type. 
    struct TParam { 
        char Data[LWTRACE_MAX_PARAM_SIZE]; 
 
        template <class T> 
        const T& Get() const { 
            return *reinterpret_cast<const T*>(Data);
        } 
 
        template <class T> 
        T& Get() { 
            return *reinterpret_cast<T*>(Data);
        } 
 
        template <class T> 
        void DefaultConstruct() { 
            new (&Data) T(); 
        } 
 
        template <class T> 
        void CopyConstruct(const T& other) { 
            new (&Data) T(other); 
        } 
 
        template <class T> 
        void Destruct() { 
            Get<T>().~T(); 
        } 
    }; 
 
    template <> 
    inline void TParam::DefaultConstruct<TNil>() { 
    } 
 
    template <> 
    inline void TParam::CopyConstruct<TNil>(const TNil&) { 
    } 
 
    template <> 
    inline void TParam::Destruct<TNil>() { 
    } 
 
    class TTypedParam { 
    private: 
        EParamTypePb Type; 
        TParam Param; // Contains garbage if PT_UNKNOWN 
    public: 
        TTypedParam() 
            : Type(PT_UNKNOWN) 
        { 
        } 
 
        explicit TTypedParam(EParamTypePb type) 
            : Type(type) 
        { 
            switch (Type) { 
#define FOREACH_PARAMTYPE_MACRO(n, t, v) \ 
    case PT_##v:                         \ 
        Param.DefaultConstruct<t>();     \ 
        return; 
                FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
#undef FOREACH_PARAMTYPE_MACRO 
                case PT_UNKNOWN: 
                    return; 
                default: 
                    Y_FAIL("unknown param type"); 
            } 
        } 
 
        template <class T> 
        explicit TTypedParam(const T& x, EParamTypePb type = PT_UNKNOWN) 
            : Type(type) 
        { 
            Param.CopyConstruct<T>(x); 
        } 
 
#define FOREACH_PARAMTYPE_MACRO(n, t, v) \ 
    explicit TTypedParam(const t& x)     \ 
        : Type(PT_##v) {                 \ 
        Param.CopyConstruct<t>(x);       \ 
    } 
        FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
#undef FOREACH_PARAMTYPE_MACRO 
 
        TTypedParam(const TTypedParam& o) { 
            Assign(o); 
        } 
 
        TTypedParam& operator=(const TTypedParam& o) { 
            Reset(); 
            Assign(o); 
            return *this; 
        } 
 
        void Assign(const TTypedParam& o) { 
            Type = o.Type; 
            switch (Type) { 
#define FOREACH_PARAMTYPE_MACRO(n, t, v)          \ 
    case PT_##v:                                  \ 
        Param.CopyConstruct<t>(o.Param.Get<t>()); \ 
        return; 
                FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
#undef FOREACH_PARAMTYPE_MACRO 
                case PT_UNKNOWN: 
                    return; 
                default: 
                    Y_FAIL("unknown param type"); 
            } 
        } 
 
        TTypedParam(TTypedParam&& o) 
            : Type(o.Type) 
            , Param(o.Param) 
        { 
            o.Type = PT_UNKNOWN; // To avoid Param destroy by source object dtor 
        } 
 
        TTypedParam(EParamTypePb type, const TParam& param) 
            : Type(type) 
        { 
            Y_UNUSED(param); // for disabled lwtrace 
            switch (Type) { 
#define FOREACH_PARAMTYPE_MACRO(n, t, v)        \ 
    case PT_##v:                                \ 
        Param.CopyConstruct<t>(param.Get<t>()); \ 
        return; 
                FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
#undef FOREACH_PARAMTYPE_MACRO 
                case PT_UNKNOWN: 
                    return; 
                default: 
                    Y_FAIL("unknown param type"); 
            } 
        } 
 
        ~TTypedParam() { 
            Reset(); 
        } 
 
        void Reset() { 
            switch (Type) { 
#define FOREACH_PARAMTYPE_MACRO(n, t, v) \ 
    case PT_##v:                         \ 
        Param.Destruct<t>();             \ 
        return; 
                FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
#undef FOREACH_PARAMTYPE_MACRO 
                case PT_UNKNOWN: 
                    return; 
                default: 
                    Y_FAIL("unknown param type"); 
            } 
            Type = PT_UNKNOWN; 
        } 
 
        bool operator==(const TTypedParam& rhs) const { 
            if (Y_LIKELY(Type == rhs.Type)) { 
                switch (Type) { 
#define FOREACH_PARAMTYPE_MACRO(n, t, v) \ 
    case PT_##v:                         \ 
        return Param.Get<t>() == rhs.Param.Get<t>(); 
                    FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
#undef FOREACH_PARAMTYPE_MACRO 
                    case PT_UNKNOWN: 
                        return false; // All unknowns are equal 
                    default: 
                        Y_FAIL("unknown param type"); 
                } 
            } else { 
                return false; 
            } 
        } 
        bool operator!=(const TTypedParam& rhs) const { 
            return !operator==(rhs); 
        } 
 
        bool operator<(const TTypedParam& rhs) const { 
            if (Y_LIKELY(Type == rhs.Type)) { 
                switch (Type) { 
#define FOREACH_PARAMTYPE_MACRO(n, t, v) \ 
    case PT_##v:                         \ 
        return Param.Get<t>() < rhs.Param.Get<t>(); 
                    FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
#undef FOREACH_PARAMTYPE_MACRO 
                    case PT_UNKNOWN: 
                        return false; // All unknowns are equal 
                    default: 
                        Y_FAIL("unknown param type"); 
                } 
            } else { 
                return Type < rhs.Type; 
            } 
        } 
 
        bool operator<=(const TTypedParam& rhs) const { 
            if (Y_LIKELY(Type == rhs.Type)) { 
                switch (Type) { 
#define FOREACH_PARAMTYPE_MACRO(n, t, v) \ 
    case PT_##v:                         \ 
        return Param.Get<t>() <= rhs.Param.Get<t>(); 
                    FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
#undef FOREACH_PARAMTYPE_MACRO 
                    case PT_UNKNOWN: 
                        return true; // All unknowns are equal 
                    default: 
                        Y_FAIL("unknown param type"); 
                } 
            } else { 
                return Type < rhs.Type; 
            } 
        } 
 
        bool operator>(const TTypedParam& rhs) const { 
            return !operator<=(rhs); 
        } 
        bool operator>=(const TTypedParam& rhs) const { 
            return !operator<(rhs); 
        } 
 
        EParamTypePb GetType() const { 
            return Type; 
        } 
        const TParam& GetParam() const { 
            return Param; 
        } 
    }; 
 
    class TLiteral { 
    private: 
        TTypedParam Values[EParamTypePb_ARRAYSIZE]; 

    public: 
        explicit TLiteral(const TString& text) { 
            Y_UNUSED(text); /* That's for windows, where we have lwtrace disabled. */ 
 
#define FOREACH_PARAMTYPE_MACRO(n, t, v)                               \ 
    try {                                                              \ 
        Values[PT_##v] = TTypedParam(TParamConv<t>::FromString(text)); \ 
    } catch (...) {                                                    \ 
        Values[PT_##v] = TTypedParam();                                \ 
    }                                                                  \ 
    /**/ 
            FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
#undef FOREACH_PARAMTYPE_MACRO 
        } 
 
        TLiteral() { 
        } 
 
        TLiteral(const TLiteral& o) { 
            for (size_t i = 0; i < EParamTypePb_ARRAYSIZE; i++) { 
                Values[i] = o.Values[i]; 
            } 
        } 
 
        TLiteral& operator=(const TLiteral& o) { 
            for (size_t i = 0; i < EParamTypePb_ARRAYSIZE; i++) { 
                Values[i] = o.Values[i]; 
            } 
            return *this; 
        } 
 
        const TTypedParam& GetValue(EParamTypePb type) const { 
            return Values[type]; 
        } 
 
        bool operator==(const TTypedParam& rhs) const { 
            return Values[rhs.GetType()] == rhs; 
        } 
        bool operator!=(const TTypedParam& rhs) const { 
            return !operator==(rhs); 
        } 
 
        bool operator<(const TTypedParam& rhs) const { 
            return Values[rhs.GetType()] < rhs; 
        } 
 
        bool operator<=(const TTypedParam& rhs) const { 
            return Values[rhs.GetType()] <= rhs; 
        } 
 
        bool operator>(const TTypedParam& rhs) const { 
            return !operator<=(rhs); 
        } 
        bool operator>=(const TTypedParam& rhs) const { 
            return !operator<(rhs); 
        } 
    }; 
 
    inline bool operator==(const TTypedParam& lhs, const TLiteral& rhs) { 
        return lhs == rhs.GetValue(lhs.GetType()); 
    } 
    inline bool operator!=(const TTypedParam& lhs, const TLiteral& rhs) { 
        return !operator==(lhs, rhs); 
    } 
 
    inline bool operator<(const TTypedParam& lhs, const TLiteral& rhs) { 
        return lhs < rhs.GetValue(lhs.GetType()); 
    } 
 
    inline bool operator<=(const TTypedParam& lhs, const TLiteral& rhs) { 
        return lhs <= rhs.GetValue(lhs.GetType()); 
    } 
 
    inline bool operator>(const TTypedParam& lhs, const TLiteral& rhs) { 
        return !operator<=(lhs, rhs); 
    } 
    inline bool operator>=(const TTypedParam& lhs, const TLiteral& rhs) { 
        return !operator<(lhs, rhs); 
    } 
 
    // Struct that holds and handles all parameter values of different supported types 
    struct TParams { 
        TParam Param[LWTRACE_MAX_PARAMS]; 
    }; 
 
    using TSerializedParams = google::protobuf::RepeatedPtrField<NLWTrace::TTraceParam>;

    // Represents a common class for all function "signatures" (parameter types and names). 
    // Provides non-virtual interface to handle the signature and (emulated) virtual interface to handle TParams corresponding to the signature 
    struct TSignature { 
        const char** ParamTypes; 
        const char* ParamNames[LWTRACE_MAX_PARAMS + 1]; 
        size_t ParamCount; 
 
        // Virtual table 
        void (*SerializeParamsFunc)(const TParams& params, TString* values); 
        void (*CloneParamsFunc)(TParams& newParams, const TParams& oldParams); 
        void (*DestroyParamsFunc)(TParams& params); 
        void (*SerializeToPbFunc)(const TParams& params, TSerializedParams& arr);
        bool (*DeserializeFromPbFunc)(TParams& params, const TSerializedParams& arr);
 
        // Virtual calls emulation 
        void SerializeParams(const TParams& params, TString* values) const { 
            (*SerializeParamsFunc)(params, values); 
        } 
 
        void CloneParams(TParams& newParams, const TParams& oldParams) const { 
            (*CloneParamsFunc)(newParams, oldParams); 
        } 
 
        void DestroyParams(TParams& params) const { 
            (*DestroyParamsFunc)(params); 
        } 
 
        void SerializeToPb(const TParams& params, TSerializedParams& arr) const
        {
            (*SerializeToPbFunc)(params, arr);
        }

        bool DeserializeFromPb(TParams& params, const TSerializedParams& arr) const
        {
            return (*DeserializeFromPbFunc)(params, arr);
        }

        void ToProtobuf(TEventPb& pb) const; 
 
        size_t FindParamIndex(const TString& param) const { 
            for (size_t i = 0; i < ParamCount; i++) { 
                if (ParamNames[i] == param) { 
                    return i; 
                } 
            } 
            return size_t(-1); 
        } 
    }; 
 
#ifndef LWTRACE_DISABLE 
 
    // Implementation. Used for compilation error if not all expected parameters passed to a function call 
    struct ERROR_not_enough_parameters : TNil {}; 
 
    // Struct that holds static string with a name of parameter type 
    template <class T> 
    struct TParamType { 
        enum { Supported = 0 }; 
        static const char* NameString; 
    }; 
 
#define FOREACH_PARAMTYPE_MACRO(n, t, v) \ 
    template <>                          \ 
    struct TParamType<t> {               \ 
        enum { Supported = 1 };          \ 
        static const char* NameString;   \ 
    };                                   \ 
    /**/ 
    FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
    FOR_NIL_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
#undef FOREACH_PARAMTYPE_MACRO 
 
    template <class T> 
    struct TParamTraits;

    // Enum types traits impl.
    template <class TEnum, class = std::enable_if_t<std::is_enum_v<TEnum>>>
    struct TEnumParamTraitsImpl {
        using TStoreType = typename TParamTraits<std::underlying_type_t<TEnum>>::TStoreType;
        using TFuncParam = TEnum;

        inline static void ToString(typename TTypeTraits<TStoreType>::TFuncParam stored, TString* out) { 
            if constexpr (google::protobuf::is_proto_enum<TEnum>::value) {
                const google::protobuf::EnumValueDescriptor* valueDescriptor = google::protobuf::GetEnumDescriptor<TEnum>()->FindValueByNumber(stored);
                if (valueDescriptor) {
                    *out = TStringBuilder() << valueDescriptor->name() << " (" << stored << ")";
                } else {
                    *out = TParamConv<TStoreType>::ToString(stored);
                }
            } else {
                *out = TParamConv<TStoreType>::ToString(stored);
            }
        } 

        inline static TStoreType ToStoreType(TFuncParam v) {
            return static_cast<TStoreType>(v);
        }
    }; 
 
    template <class TCustomType>
    struct TCustomTraitsImpl {
        using TStoreType = typename TParamTraits<typename TCustomType::TStoreType>::TStoreType; //see STORE_TYPE_AS
        using TFuncParam = typename TCustomType::TFuncParam;

        inline static void ToString(typename TTypeTraits<TStoreType>::TFuncParam stored, TString* out) {
            TCustomType::ToString(stored, out);
        }

        inline static TStoreType ToStoreType(TFuncParam v) {
            return TCustomType::ToStoreType(v);
        }
    };

    template <class T, bool isEnum>
    struct TParamTraitsImpl;

    template <class TEnum>
    struct TParamTraitsImpl<TEnum, true> : TEnumParamTraitsImpl<TEnum> {
    };

    template <class TCustomType>
    struct TParamTraitsImpl<TCustomType, false> : TCustomTraitsImpl<TCustomType> {
    };

    template <class T>
    struct TParamTraits : TParamTraitsImpl<T, std::is_enum_v<T>> {
    };

    // Standard stored types traits.

#define STORE_TYPE_AS(input_t, store_as_t)                                                      \ 
    template <>                                                                                 \ 
    struct TParamTraits<input_t> {                                                              \ 
        using TStoreType = store_as_t;                                                          \
        using TFuncParam = typename TTypeTraits<input_t>::TFuncParam;                           \
                                                                                                \
        inline static void ToString(typename TTypeTraits<TStoreType>::TFuncParam stored, TString* out) { \
            *out = TParamConv<TStoreType>::ToString(stored);                                    \ 
        }                                                                                       \ 
                                                                                                \
        inline static TStoreType ToStoreType(TFuncParam v) {                                    \
            return v;                                                                           \
        }                                                                                       \
    };                                                                                          \ 
    /**/ 
    STORE_TYPE_AS(ui8, ui64); 
    STORE_TYPE_AS(i8, i64); 
    STORE_TYPE_AS(ui16, ui64); 
    STORE_TYPE_AS(i16, i64); 
    STORE_TYPE_AS(ui32, ui64); 
    STORE_TYPE_AS(i32, i64); 
    STORE_TYPE_AS(bool, ui64); 
    STORE_TYPE_AS(float, double); 
#define FOREACH_PARAMTYPE_MACRO(n, t, v) STORE_TYPE_AS(t, t)
    FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO) 
#undef STORE_TYPE_AS
#undef FOREACH_PARAMTYPE_MACRO 
 
    // Nil type staits.
    template <> 
    struct TParamTraits<TNil> { 
        using TStoreType = TNil;
        using TFuncParam = TTypeTraits<TNil>::TFuncParam;

        inline static void ToString(typename TTypeTraits<TNil>::TFuncParam, TString*) {
        } 

        inline static TNil ToStoreType(TFuncParam v) {
            return v;
        }
    }; 
 
    inline EParamTypePb ParamTypeToProtobuf(const char* paramType) {
#define FOREACH_PARAMTYPE_MACRO(n, t, v) \
    if (strcmp(paramType, n) == 0) {     \
        return PT_##v;                   \
    }                                    \
    /**/
        FOREACH_PARAMTYPE(FOREACH_PARAMTYPE_MACRO)
#undef FOREACH_PARAMTYPE_MACRO
        return PT_UNKNOWN;
    }

    template <typename T>
    inline void SaveParamToPb(TSerializedParams& msg, const TParam& param);

    template <>
    inline void SaveParamToPb<TNil>(TSerializedParams& msg, const TParam& param)
    {
        Y_UNUSED(msg);
        Y_UNUSED(param);
    }

    template <>
    inline void SaveParamToPb<i64>(TSerializedParams& msg, const TParam& param)
    {
        msg.Add()->SetIntValue(param.Get<typename TParamTraits<i64>::TStoreType>());
    }

    template <>
    inline void SaveParamToPb<ui64>(TSerializedParams& msg, const TParam& param)
    {
        msg.Add()->SetUintValue(param.Get<typename TParamTraits<ui64>::TStoreType>());
    }

    template <>
    inline void SaveParamToPb<double>(TSerializedParams& msg, const TParam& param)
    {
        msg.Add()->SetDoubleValue(param.Get<typename TParamTraits<double>::TStoreType>());
    }

    template <>
    inline void SaveParamToPb<TString>(TSerializedParams& msg, const TParam& param)
    {
        msg.Add()->SetStrValue(param.Get<typename TParamTraits<TString>::TStoreType>());
    }

    template <>
    inline void SaveParamToPb<TSymbol>(TSerializedParams& msg, const TParam& param)
    {
        msg.Add()->SetStrValue(*param.Get<typename TParamTraits<TSymbol>::TStoreType>().Str);
    }

    template <>
    inline void SaveParamToPb<TCheck>(TSerializedParams& msg, const TParam& param)
    {
        msg.Add()->SetIntValue(param.Get<typename TParamTraits<TCheck>::TStoreType>().Value);
    }

    template <typename T>
    inline void LoadParamFromPb(const TTraceParam& msg, TParam& param);

    template <>
    inline void LoadParamFromPb<i64>(const TTraceParam& msg, TParam& param)
    {
        param.DefaultConstruct<i64>();
        param.Get<i64>() = msg.GetIntValue();
    }

    template <>
    inline void LoadParamFromPb<ui64>(const TTraceParam& msg, TParam& param)
    {
        param.DefaultConstruct<ui64>();
        param.Get<ui64>() = msg.GetUintValue();
    }

    template <>
    inline void LoadParamFromPb<double>(const TTraceParam& msg, TParam& param)
    {
        param.DefaultConstruct<double>();
        param.Get<double>() = msg.GetDoubleValue();
    }

    template <>
    inline void LoadParamFromPb<TCheck>(const TTraceParam& msg, TParam& param)
    {
        param.CopyConstruct<TCheck>(TCheck(msg.GetIntValue()));
    }

    template <>
    inline void LoadParamFromPb<TSymbol>(const TTraceParam& msg, TParam& param)
    {
        Y_UNUSED(msg);
        Y_UNUSED(param);
        static TString unsupported("unsupported");
        // so far TSymbol deserialization is not supported
        // since it is not used for probes, it is ok
        param.CopyConstruct<TSymbol>(TSymbol(&unsupported));
    }

    template <>
    inline void LoadParamFromPb<TString>(const TTraceParam& msg, TParam& param)
    {
        param.DefaultConstruct<TString>();
        param.Get<TString>() = msg.GetStrValue();
    }

    template <>
    inline void LoadParamFromPb<TNil>(const TTraceParam& msg, TParam& param)
    {
        Y_UNUSED(msg);
        Y_UNUSED(param);
    }

    // Class representing a specific signature 
    template <LWTRACE_TEMPLATE_PARAMS> 
    struct TUserSignature { 
#define FOREACH_PARAMNUM_MACRO(i) static_assert(TParamType<typename TParamTraits<TP##i>::TStoreType>::Supported == 1, "expect TParamType< typename TParamTraits<TP ## i>::TStoreType >::Supported == 1"); 
        FOREACH_PARAMNUM(FOREACH_PARAMNUM_MACRO) // ERROR: unsupported type used as probe/event parameter type 
#undef FOREACH_PARAMNUM_MACRO 
        static const char* ParamTypes[]; 
        static const int ParamCount = LWTRACE_COUNT_PARAMS; 
 
        // Implementation of virtual function (TSignature derived classes vtable emulation) 
        inline static void SerializeParams(const TParams& params, TString* values) { 
#define FOREACH_PARAMNUM_MACRO(i) TParamTraits<TP##i>::ToString(params.Param[i].Get<typename TParamTraits<TP##i>::TStoreType>(), values + i); 
            FOREACH_PARAMNUM(FOREACH_PARAMNUM_MACRO); 
#undef FOREACH_PARAMNUM_MACRO 
        } 
 
        // Implementation of virtual function (TSignature derived classes vtable emulation) 
        inline static void CloneParams(TParams& newParams, const TParams& oldParams) { 
#define FOREACH_PARAMNUM_MACRO(i) newParams.Param[i].CopyConstruct<typename TParamTraits<TP##i>::TStoreType>(oldParams.Param[i].Get<typename TParamTraits<TP##i>::TStoreType>()); 
            FOREACH_PARAMNUM(FOREACH_PARAMNUM_MACRO); 
#undef FOREACH_PARAMNUM_MACRO 
        } 
 
        // Implementation of virtual function (TSignature derived classes vtable emulation) 
        inline static void DestroyParams(TParams& params) { 
#define FOREACH_PARAMNUM_MACRO(i) params.Param[i].Destruct<typename TParamTraits<TP##i>::TStoreType>(); 
            FOREACH_PARAMNUM(FOREACH_PARAMNUM_MACRO); 
#undef FOREACH_PARAMNUM_MACRO 
        } 

        // Implementation of virtual function (TSignature derived classes vtable emulation)
        inline static void SerializeToPb(const TParams& params, TSerializedParams& arr)
        {
#define FOREACH_PARAMNUM_MACRO(i)                                              \
    SaveParamToPb<typename TParamTraits<TP##i>::TStoreType>(                   \
        arr,                                                                   \
        params.Param[i]);                                                      \
// FOREACH_PARAMNUM_MACRO
            FOREACH_PARAMNUM(FOREACH_PARAMNUM_MACRO);
#undef FOREACH_PARAMNUM_MACRO
        }

        // Implementation of virtual function (TSignature derived classes vtable emulation)
        inline static bool DeserializeFromPb(TParams& params, const TSerializedParams& arr) {
            if (arr.size() != ParamCount) {
                return false;
            }
            if (!ParamCount) {
                return true;
            }

            int paramIdx = 0;
#define FOREACH_PARAMNUM_MACRO(i)                                              \
    if (paramIdx >= arr.size()) {                                              \
        return true;                                                           \
    };                                                                         \
    LoadParamFromPb<typename TParamTraits<TP##i>::TStoreType>(                 \
        arr.Get(paramIdx),                                                     \
        params.Param[paramIdx]);                                               \
    ++paramIdx;                                                                \
//  FOREACH_PARAMNUM_MACRO
            FOREACH_PARAMNUM(FOREACH_PARAMNUM_MACRO);
#undef FOREACH_PARAMNUM_MACRO
            return true;
        }
    }; 
 
    // Array of static strings pointers for names of parameter types in a specific signature 
    template <LWTRACE_TEMPLATE_PARAMS_NODEF> 
    const char* TUserSignature<LWTRACE_TEMPLATE_ARGS>::ParamTypes[] = { 
#define FOREACH_PARAMNUM_MACRO(i) TParamType<typename TParamTraits<TP##i>::TStoreType>::NameString, 
        FOREACH_PARAMNUM(FOREACH_PARAMNUM_MACRO) nullptr 
#undef FOREACH_PARAMNUM_MACRO 
    }; 
 
    inline void TSignature::ToProtobuf(TEventPb& pb) const { 
        for (size_t i = 0; i < ParamCount; i++) { 
            pb.AddParamTypes(ParamTypeToProtobuf(ParamTypes[i])); 
            pb.AddParamNames(ParamNames[i]); 
        } 
    } 
 
#else 
 
    inline void TSignature::ToProtobuf(TEventPb&) const { 
    } 
 
    inline EParamTypePb ParamTypeToProtobuf(const char*) { 
        return PT_UNKNOWN; 
    } 
 
#endif 
 
}