14380371690

Committed 10 Apr 2025 12:25PM UTC coverage: 99.352% (-0.3%) from 99.673%

Build # 14380371690

Build Type

push

github

Committed by

afxres

Commit Message

Use functions for variant converter

Run Details

32 of 33 new or added lines in 1 file covered. (96.97%)

1 existing line in 1 file now uncovered.

613 of 617 relevant lines covered (99.35%)

95.47 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.24

/code/binary/include/binary/converters/VariantConverter.hpp

#ifndef BINARY_CONVERTERS_VARIANTCONVERTER_HPP
#define BINARY_CONVERTERS_VARIANTCONVERTER_HPP

#include <memory>
#include <variant>

#include "binary/Converter.hpp"
#include "binary/ConverterExtensions.hpp"

namespace binary::converters {
template <typename T>
class VariantConverter;

template <template <typename...> typename T, typename... E>
    requires requires { std::variant_size<T<E...>>::value; }
class VariantConverter<T<E...>> : public Converter<T<E...>> {
private:
    using ConverterTargetType = T<E...>;
    using EncodeFunction = std::function<void(Allocator&, const ConverterTargetType&)>;
    using DecodeFunction = std::function<ConverterTargetType(std::span<const std::byte>&)>;

    struct MethodInfo {
        EncodeFunction Encode;
        EncodeFunction EncodeAuto;
        DecodeFunction Decode;
        DecodeFunction DecodeAuto;
    };

    template <size_t Index>
    static MethodInfo GetMethodInfo(const auto& converter) {
        MethodInfo result;
        result.Encode = [converter](auto& allocator, const auto& item) { converter->Encode(allocator, std::get<Index>(item)); };
        result.EncodeAuto = [converter](auto& allocator, const auto& item) { converter->EncodeAuto(allocator, std::get<Index>(item)); };
        result.Decode = [converter](auto& span) { return ConverterTargetType(std::in_place_index<Index>, converter->Decode(span)); };
        result.DecodeAuto = [converter](auto& span) { return ConverterTargetType(std::in_place_index<Index>, converter->DecodeAuto(span)); };
        return result;
    }

    template <size_t... Index>
    static std::vector<MethodInfo> GetMethodInfoList(const std::shared_ptr<Converter<std::remove_cv_t<E>>>&... converter, std::index_sequence<Index...>) {
        std::vector<MethodInfo> result;
        (result.emplace_back(GetMethodInfo<Index>(converter)), ...);
        return result;
    }

    template <size_t IsAuto>
    void EncodeInternal(Allocator& allocator, const ConverterTargetType& item) {
        auto header = item.index();
        const auto& record = this->record;
        if (header >= record.size()) {
            throw std::invalid_argument("invalid variant value");
        }

        ::binary::Encode(allocator, header);
        if constexpr (IsAuto == 0) {
            record.at(header).Encode(allocator, item);
        } else {
            record.at(header).EncodeAuto(allocator, item);
        }
    }

    template <size_t IsAuto>
    ConverterTargetType DecodeInternal(std::span<const std::byte>& span) {
        auto header = ::binary::Decode(span);
        const auto& record = this->record;
        if (header >= record.size()) {
            throw std::invalid_argument("invalid variant index");
        }

        if constexpr (IsAuto == 0) {
            return record.at(header).Decode(span);
        } else {
            return record.at(header).DecodeAuto(span);
        }
    }

    const std::vector<MethodInfo> record;

public:
    VariantConverter(const std::shared_ptr<Converter<std::remove_cv_t<E>>>&... converter)
        : record(GetMethodInfoList(converter..., std::make_index_sequence<sizeof...(E)>())) {}

    virtual void Encode(Allocator& allocator, const ConverterTargetType& item) override {
        EncodeInternal<0>(allocator, item);
    }

    virtual void EncodeAuto(Allocator& allocator, const ConverterTargetType& item) override {
        EncodeInternal<1>(allocator, item);
    }

    virtual ConverterTargetType Decode(const std::span<const std::byte>& span) override {
        std::span<const std::byte> copy = span;
        return DecodeInternal<0>(copy);
    }

    virtual ConverterTargetType DecodeAuto(std::span<const std::byte>& span) override {
        return DecodeInternal<1>(span);
    }
};
}

#endif

1	#ifndef BINARY_CONVERTERS_VARIANTCONVERTER_HPP
2	#define BINARY_CONVERTERS_VARIANTCONVERTER_HPP
3
4	#include <memory>
5	#include <variant>
6
7	#include "binary/Converter.hpp"
8	#include "binary/ConverterExtensions.hpp"
9
10	namespace binary::converters {
11	template <typename T>
12	class VariantConverter;
13
14	template <template <typename...> typename T, typename... E>
15	requires requires { std::variant_size<T<E...>>::value; }
16	class VariantConverter<T<E...>> : public Converter<T<E...>> {
17	private:
18	using ConverterTargetType = T<E...>;
19	using EncodeFunction = std::function<void(Allocator&, const ConverterTargetType&)>;
20	using DecodeFunction = std::function<ConverterTargetType(std::span<const std::byte>&)>;
21
22	struct MethodInfo {
23	EncodeFunction Encode;
24	EncodeFunction EncodeAuto;
25	DecodeFunction Decode;
26	DecodeFunction DecodeAuto;
27	};
28
29	template <size_t Index>
30	static MethodInfo GetMethodInfo(const auto& converter) {	49✔
31	MethodInfo result;	49✔
32	result.Encode = [converter](auto& allocator, const auto& item) { converter->Encode(allocator, std::get<Index>(item)); };	57✔
33	result.EncodeAuto = [converter](auto& allocator, const auto& item) { converter->EncodeAuto(allocator, std::get<Index>(item)); };	57✔
34	result.Decode = [converter](auto& span) { return ConverterTargetType(std::in_place_index<Index>, converter->Decode(span)); };	57✔
35	result.DecodeAuto = [converter](auto& span) { return ConverterTargetType(std::in_place_index<Index>, converter->DecodeAuto(span)); };	57✔
36	return result;	49✔
UNCOV 37	}	×
38
39	template <size_t... Index>
40	static std::vector<MethodInfo> GetMethodInfoList(const std::shared_ptr<Converter<std::remove_cv_t<E>>>&... converter, std::index_sequence<Index...>) {	21✔
41	std::vector<MethodInfo> result;	21✔
42	(result.emplace_back(GetMethodInfo<Index>(converter)), ...);	21✔
43	return result;	21✔
NEW 44	}	×
45
46	template <size_t IsAuto>
47	void EncodeInternal(Allocator& allocator, const ConverterTargetType& item) {	17✔
48	auto header = item.index();	17✔
49	const auto& record = this->record;	17✔
50	if (header >= record.size()) {	17✔
51	throw std::invalid_argument("invalid variant value");	1✔
52	}
53
54	::binary::Encode(allocator, header);	16✔
55	if constexpr (IsAuto == 0) {
56	record.at(header).Encode(allocator, item);	8✔
57	} else {
58	record.at(header).EncodeAuto(allocator, item);	8✔
59	}
60	}	16✔
61
62	template <size_t IsAuto>
63	ConverterTargetType DecodeInternal(std::span<const std::byte>& span) {	28✔
64	auto header = ::binary::Decode(span);	28✔
65	const auto& record = this->record;	28✔
66	if (header >= record.size()) {	28✔
67	throw std::invalid_argument("invalid variant index");	12✔
68	}
69
70	if constexpr (IsAuto == 0) {
71	return record.at(header).Decode(span);	8✔
72	} else {
73	return record.at(header).DecodeAuto(span);	8✔
74	}
75	}
76
77	const std::vector<MethodInfo> record;
78
79	public:
80	VariantConverter(const std::shared_ptr<Converter<std::remove_cv_t<E>>>&... converter)	21✔
81	: record(GetMethodInfoList(converter..., std::make_index_sequence<sizeof...(E)>())) {}	21✔
82
83	virtual void Encode(Allocator& allocator, const ConverterTargetType& item) override {	9✔
84	EncodeInternal<0>(allocator, item);	9✔
85	}	8✔
86
87	virtual void EncodeAuto(Allocator& allocator, const ConverterTargetType& item) override {	8✔
88	EncodeInternal<1>(allocator, item);	8✔
89	}	8✔
90
91	virtual ConverterTargetType Decode(const std::span<const std::byte>& span) override {	14✔
92	std::span<const std::byte> copy = span;	14✔
93	return DecodeInternal<0>(copy);	22✔
94	}
95
96	virtual ConverterTargetType DecodeAuto(std::span<const std::byte>& span) override {	14✔
97	return DecodeInternal<1>(span);	14✔
98	}
99	};
100	}
101
102	#endif

afxres / binary-cxx / 14380371690

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous