Coverage Report

Created: 2026-10-19 15:26

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/tmp/bitcoin/src/serialize.h
Line
Count
Source
1
// Copyright (c) 2009-2010 Satoshi Nakamoto
2
// Copyright (c) 2009-present The Bitcoin Core developers
3
// Distributed under the MIT software license, see the accompanying
4
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
5
6
#ifndef BITCOIN_SERIALIZE_H
7
#define BITCOIN_SERIALIZE_H
8
9
#include <attributes.h>
10
#include <compat/assumptions.h> // IWYU pragma: keep
11
#include <compat/endian.h>
12
#include <prevector.h>
13
#include <span.h>
14
#include <util/overflow.h>
15
16
#include <algorithm>
17
#include <concepts>
18
#include <cstdint>
19
#include <cstring>
20
#include <ios>
21
#include <limits>
22
#include <map>
23
#include <memory>
24
#include <set>
25
#include <span>
26
#include <string>
27
#include <string_view>
28
#include <utility>
29
#include <vector>
30
31
/**
32
 * The maximum size of a serialized object in bytes or number of elements
33
 * (for eg vectors) when the size is encoded as CompactSize.
34
 */
35
inline constexpr uint64_t MAX_SIZE = 0x02000000;
36
37
/** Maximum amount of memory (in bytes) to allocate at once when deserializing vectors. */
38
inline constexpr unsigned int MAX_VECTOR_ALLOCATE{5'000'000};
39
40
/**
41
 * Dummy data type to identify deserializing constructors.
42
 *
43
 * By convention, a constructor of a type T with signature
44
 *
45
 *   template <typename Stream> T::T(deserialize_type, Stream& s)
46
 *
47
 * is a deserializing constructor, which builds the type by
48
 * deserializing it from s. If T contains const fields, this
49
 * is likely the only way to do so.
50
 */
51
struct deserialize_type {};
52
inline constexpr deserialize_type deserialize {};
53
54
/*
55
 * Lowest-level serialization and conversion.
56
 */
57
template<typename Stream> inline void ser_writedata8(Stream &s, uint8_t obj)
58
91.9M
{
59
91.9M
    s.write(std::as_bytes(std::span{&obj, 1}));
60
91.9M
}
void ser_writedata8<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, unsigned char)
Line
Count
Source
58
26.7M
{
59
26.7M
    s.write(std::as_bytes(std::span{&obj, 1}));
60
26.7M
}
void ser_writedata8<DataStream>(DataStream&, unsigned char)
Line
Count
Source
58
25.0M
{
59
25.0M
    s.write(std::as_bytes(std::span{&obj, 1}));
60
25.0M
}
void ser_writedata8<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned char)
Line
Count
Source
58
74
{
59
74
    s.write(std::as_bytes(std::span{&obj, 1}));
60
74
}
void ser_writedata8<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char)
Line
Count
Source
58
36
{
59
36
    s.write(std::as_bytes(std::span{&obj, 1}));
60
36
}
void ser_writedata8<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, unsigned char)
Line
Count
Source
58
1.19M
{
59
1.19M
    s.write(std::as_bytes(std::span{&obj, 1}));
60
1.19M
}
void ser_writedata8<VectorWriter>(VectorWriter&, unsigned char)
Line
Count
Source
58
533k
{
59
533k
    s.write(std::as_bytes(std::span{&obj, 1}));
60
533k
}
void ser_writedata8<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, unsigned char)
Line
Count
Source
58
591k
{
59
591k
    s.write(std::as_bytes(std::span{&obj, 1}));
60
591k
}
void ser_writedata8<AutoFile>(AutoFile&, unsigned char)
Line
Count
Source
58
240k
{
59
240k
    s.write(std::as_bytes(std::span{&obj, 1}));
60
240k
}
void ser_writedata8<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&, unsigned char)
Line
Count
Source
58
15.2M
{
59
15.2M
    s.write(std::as_bytes(std::span{&obj, 1}));
60
15.2M
}
void ser_writedata8<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned char)
Line
Count
Source
58
167
{
59
167
    s.write(std::as_bytes(std::span{&obj, 1}));
60
167
}
void ser_writedata8<SizeComputer>(SizeComputer&, unsigned char)
Line
Count
Source
58
857k
{
59
857k
    s.write(std::as_bytes(std::span{&obj, 1}));
60
857k
}
void ser_writedata8<HashWriter>(HashWriter&, unsigned char)
Line
Count
Source
58
18.3M
{
59
18.3M
    s.write(std::as_bytes(std::span{&obj, 1}));
60
18.3M
}
void ser_writedata8<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>>(ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, unsigned char)
Line
Count
Source
58
2
{
59
2
    s.write(std::as_bytes(std::span{&obj, 1}));
60
2
}
void ser_writedata8<ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>>(ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>&, unsigned char)
Line
Count
Source
58
1
{
59
1
    s.write(std::as_bytes(std::span{&obj, 1}));
60
1
}
void ser_writedata8<ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>>(ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>&, unsigned char)
Line
Count
Source
58
1
{
59
1
    s.write(std::as_bytes(std::span{&obj, 1}));
60
1
}
void ser_writedata8<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, unsigned char)
Line
Count
Source
58
5
{
59
5
    s.write(std::as_bytes(std::span{&obj, 1}));
60
5
}
void ser_writedata8<ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>>(ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>&, unsigned char)
Line
Count
Source
58
1
{
59
1
    s.write(std::as_bytes(std::span{&obj, 1}));
60
1
}
void ser_writedata8<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, unsigned char)
Line
Count
Source
58
2
{
59
2
    s.write(std::as_bytes(std::span{&obj, 1}));
60
2
}
void ser_writedata8<SpanWriter>(SpanWriter&, unsigned char)
Line
Count
Source
58
8
{
59
8
    s.write(std::as_bytes(std::span{&obj, 1}));
60
8
}
void ser_writedata8<HashedSourceWriter<DataStream>>(HashedSourceWriter<DataStream>&, unsigned char)
Line
Count
Source
58
1
{
59
1
    s.write(std::as_bytes(std::span{&obj, 1}));
60
1
}
Unexecuted instantiation: void ser_writedata8<ParamsStream<VectorWriter&, CNetAddr::SerParams>>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, unsigned char)
void ser_writedata8<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, unsigned char)
Line
Count
Source
58
154k
{
59
154k
    s.write(std::as_bytes(std::span{&obj, 1}));
60
154k
}
void ser_writedata8<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char)
Line
Count
Source
58
100k
{
59
100k
    s.write(std::as_bytes(std::span{&obj, 1}));
60
100k
}
void ser_writedata8<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char)
Line
Count
Source
58
66
{
59
66
    s.write(std::as_bytes(std::span{&obj, 1}));
60
66
}
void ser_writedata8<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&, unsigned char)
Line
Count
Source
58
652k
{
59
652k
    s.write(std::as_bytes(std::span{&obj, 1}));
60
652k
}
void ser_writedata8<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, unsigned char)
Line
Count
Source
58
2.27M
{
59
2.27M
    s.write(std::as_bytes(std::span{&obj, 1}));
60
2.27M
}
void ser_writedata8<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, unsigned char)
Line
Count
Source
58
15.7k
{
59
15.7k
    s.write(std::as_bytes(std::span{&obj, 1}));
60
15.7k
}
61
template<typename Stream> inline void ser_writedata16(Stream &s, uint16_t obj)
62
83.5k
{
63
83.5k
    obj = htole16_internal(obj);
64
83.5k
    s.write(std::as_bytes(std::span{&obj, 1}));
65
83.5k
}
void ser_writedata16<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, unsigned short)
Line
Count
Source
62
39.7k
{
63
39.7k
    obj = htole16_internal(obj);
64
39.7k
    s.write(std::as_bytes(std::span{&obj, 1}));
65
39.7k
}
void ser_writedata16<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned short)
Line
Count
Source
62
1
{
63
1
    obj = htole16_internal(obj);
64
1
    s.write(std::as_bytes(std::span{&obj, 1}));
65
1
}
Unexecuted instantiation: void ser_writedata16<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned short)
void ser_writedata16<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, unsigned short)
Line
Count
Source
62
347
{
63
347
    obj = htole16_internal(obj);
64
347
    s.write(std::as_bytes(std::span{&obj, 1}));
65
347
}
void ser_writedata16<DataStream>(DataStream&, unsigned short)
Line
Count
Source
62
2.66k
{
63
2.66k
    obj = htole16_internal(obj);
64
2.66k
    s.write(std::as_bytes(std::span{&obj, 1}));
65
2.66k
}
void ser_writedata16<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, unsigned short)
Line
Count
Source
62
131
{
63
131
    obj = htole16_internal(obj);
64
131
    s.write(std::as_bytes(std::span{&obj, 1}));
65
131
}
void ser_writedata16<AutoFile>(AutoFile&, unsigned short)
Line
Count
Source
62
44
{
63
44
    obj = htole16_internal(obj);
64
44
    s.write(std::as_bytes(std::span{&obj, 1}));
65
44
}
void ser_writedata16<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&, unsigned short)
Line
Count
Source
62
21.2k
{
63
21.2k
    obj = htole16_internal(obj);
64
21.2k
    s.write(std::as_bytes(std::span{&obj, 1}));
65
21.2k
}
void ser_writedata16<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned short)
Line
Count
Source
62
31
{
63
31
    obj = htole16_internal(obj);
64
31
    s.write(std::as_bytes(std::span{&obj, 1}));
65
31
}
void ser_writedata16<SizeComputer>(SizeComputer&, unsigned short)
Line
Count
Source
62
5
{
63
5
    obj = htole16_internal(obj);
64
5
    s.write(std::as_bytes(std::span{&obj, 1}));
65
5
}
void ser_writedata16<HashWriter>(HashWriter&, unsigned short)
Line
Count
Source
62
12.2k
{
63
12.2k
    obj = htole16_internal(obj);
64
12.2k
    s.write(std::as_bytes(std::span{&obj, 1}));
65
12.2k
}
Unexecuted instantiation: void ser_writedata16<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, unsigned short)
Unexecuted instantiation: void ser_writedata16<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, unsigned short)
Unexecuted instantiation: void ser_writedata16<HashedSourceWriter<DataStream>>(HashedSourceWriter<DataStream>&, unsigned short)
void ser_writedata16<VectorWriter>(VectorWriter&, unsigned short)
Line
Count
Source
62
30
{
63
30
    obj = htole16_internal(obj);
64
30
    s.write(std::as_bytes(std::span{&obj, 1}));
65
30
}
Unexecuted instantiation: void ser_writedata16<ParamsStream<VectorWriter&, CNetAddr::SerParams>>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, unsigned short)
void ser_writedata16<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, unsigned short)
Line
Count
Source
62
40
{
63
40
    obj = htole16_internal(obj);
64
40
    s.write(std::as_bytes(std::span{&obj, 1}));
65
40
}
Unexecuted instantiation: void ser_writedata16<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned short)
Unexecuted instantiation: void ser_writedata16<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned short)
void ser_writedata16<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&, unsigned short)
Line
Count
Source
62
14
{
63
14
    obj = htole16_internal(obj);
64
14
    s.write(std::as_bytes(std::span{&obj, 1}));
65
14
}
void ser_writedata16<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, unsigned short)
Line
Count
Source
62
7.02k
{
63
7.02k
    obj = htole16_internal(obj);
64
7.02k
    s.write(std::as_bytes(std::span{&obj, 1}));
65
7.02k
}
void ser_writedata16<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, unsigned short)
Line
Count
Source
62
13
{
63
13
    obj = htole16_internal(obj);
64
13
    s.write(std::as_bytes(std::span{&obj, 1}));
65
13
}
66
template<typename Stream> inline void ser_writedata32(Stream &s, uint32_t obj)
67
137M
{
68
137M
    obj = htole32_internal(obj);
69
137M
    s.write(std::as_bytes(std::span{&obj, 1}));
70
137M
}
void ser_writedata32<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, unsigned int)
Line
Count
Source
67
19.2M
{
68
19.2M
    obj = htole32_internal(obj);
69
19.2M
    s.write(std::as_bytes(std::span{&obj, 1}));
70
19.2M
}
void ser_writedata32<DataStream>(DataStream&, unsigned int)
Line
Count
Source
67
5.44M
{
68
5.44M
    obj = htole32_internal(obj);
69
5.44M
    s.write(std::as_bytes(std::span{&obj, 1}));
70
5.44M
}
void ser_writedata32<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned int)
Line
Count
Source
67
7.25k
{
68
7.25k
    obj = htole32_internal(obj);
69
7.25k
    s.write(std::as_bytes(std::span{&obj, 1}));
70
7.25k
}
Unexecuted instantiation: void ser_writedata32<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned int)
void ser_writedata32<HashWriter>(HashWriter&, unsigned int)
Line
Count
Source
67
99.5M
{
68
99.5M
    obj = htole32_internal(obj);
69
99.5M
    s.write(std::as_bytes(std::span{&obj, 1}));
70
99.5M
}
void ser_writedata32<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, unsigned int)
Line
Count
Source
67
455k
{
68
455k
    obj = htole32_internal(obj);
69
455k
    s.write(std::as_bytes(std::span{&obj, 1}));
70
455k
}
void ser_writedata32<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, unsigned int)
Line
Count
Source
67
413k
{
68
413k
    obj = htole32_internal(obj);
69
413k
    s.write(std::as_bytes(std::span{&obj, 1}));
70
413k
}
void ser_writedata32<AutoFile>(AutoFile&, unsigned int)
Line
Count
Source
67
8.94k
{
68
8.94k
    obj = htole32_internal(obj);
69
8.94k
    s.write(std::as_bytes(std::span{&obj, 1}));
70
8.94k
}
void ser_writedata32<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&, unsigned int)
Line
Count
Source
67
9.06M
{
68
9.06M
    obj = htole32_internal(obj);
69
9.06M
    s.write(std::as_bytes(std::span{&obj, 1}));
70
9.06M
}
void ser_writedata32<VectorWriter>(VectorWriter&, unsigned int)
Line
Count
Source
67
315k
{
68
315k
    obj = htole32_internal(obj);
69
315k
    s.write(std::as_bytes(std::span{&obj, 1}));
70
315k
}
void ser_writedata32<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned int)
Line
Count
Source
67
18.9k
{
68
18.9k
    obj = htole32_internal(obj);
69
18.9k
    s.write(std::as_bytes(std::span{&obj, 1}));
70
18.9k
}
void ser_writedata32<SizeComputer>(SizeComputer&, unsigned int)
Line
Count
Source
67
149k
{
68
149k
    obj = htole32_internal(obj);
69
149k
    s.write(std::as_bytes(std::span{&obj, 1}));
70
149k
}
Unexecuted instantiation: void ser_writedata32<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, unsigned int)
Unexecuted instantiation: void ser_writedata32<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, unsigned int)
void ser_writedata32<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&, unsigned int)
Line
Count
Source
67
203k
{
68
203k
    obj = htole32_internal(obj);
69
203k
    s.write(std::as_bytes(std::span{&obj, 1}));
70
203k
}
Unexecuted instantiation: void ser_writedata32<HashedSourceWriter<DataStream>>(HashedSourceWriter<DataStream>&, unsigned int)
Unexecuted instantiation: void ser_writedata32<ParamsStream<VectorWriter&, CNetAddr::SerParams>>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, unsigned int)
void ser_writedata32<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, unsigned int)
Line
Count
Source
67
1.87M
{
68
1.87M
    obj = htole32_internal(obj);
69
1.87M
    s.write(std::as_bytes(std::span{&obj, 1}));
70
1.87M
}
Unexecuted instantiation: void ser_writedata32<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned int)
Unexecuted instantiation: void ser_writedata32<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned int)
void ser_writedata32<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, unsigned int)
Line
Count
Source
67
1.09M
{
68
1.09M
    obj = htole32_internal(obj);
69
1.09M
    s.write(std::as_bytes(std::span{&obj, 1}));
70
1.09M
}
void ser_writedata32<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, unsigned int)
Line
Count
Source
67
7.61k
{
68
7.61k
    obj = htole32_internal(obj);
69
7.61k
    s.write(std::as_bytes(std::span{&obj, 1}));
70
7.61k
}
void ser_writedata32<SpanWriter>(SpanWriter&, unsigned int)
Line
Count
Source
67
59
{
68
59
    obj = htole32_internal(obj);
69
59
    s.write(std::as_bytes(std::span{&obj, 1}));
70
59
}
71
template<typename Stream> inline void ser_writedata32be(Stream &s, uint32_t obj)
72
14.3k
{
73
14.3k
    obj = htobe32_internal(obj);
74
14.3k
    s.write(std::as_bytes(std::span{&obj, 1}));
75
14.3k
}
76
template<typename Stream> inline void ser_writedata64(Stream &s, uint64_t obj)
77
70.4M
{
78
70.4M
    obj = htole64_internal(obj);
79
70.4M
    s.write(std::as_bytes(std::span{&obj, 1}));
80
70.4M
}
void ser_writedata64<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, unsigned long)
Line
Count
Source
77
7.16M
{
78
7.16M
    obj = htole64_internal(obj);
79
7.16M
    s.write(std::as_bytes(std::span{&obj, 1}));
80
7.16M
}
void ser_writedata64<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned long)
Line
Count
Source
77
17
{
78
17
    obj = htole64_internal(obj);
79
17
    s.write(std::as_bytes(std::span{&obj, 1}));
80
17
}
Unexecuted instantiation: void ser_writedata64<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long)
void ser_writedata64<DataStream>(DataStream&, unsigned long)
Line
Count
Source
77
280k
{
78
280k
    obj = htole64_internal(obj);
79
280k
    s.write(std::as_bytes(std::span{&obj, 1}));
80
280k
}
void ser_writedata64<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, unsigned long)
Line
Count
Source
77
267k
{
78
267k
    obj = htole64_internal(obj);
79
267k
    s.write(std::as_bytes(std::span{&obj, 1}));
80
267k
}
void ser_writedata64<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, unsigned long)
Line
Count
Source
77
170k
{
78
170k
    obj = htole64_internal(obj);
79
170k
    s.write(std::as_bytes(std::span{&obj, 1}));
80
170k
}
void ser_writedata64<AutoFile>(AutoFile&, unsigned long)
Line
Count
Source
77
43.0M
{
78
43.0M
    obj = htole64_internal(obj);
79
43.0M
    s.write(std::as_bytes(std::span{&obj, 1}));
80
43.0M
}
void ser_writedata64<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&, unsigned long)
Line
Count
Source
77
3.83M
{
78
3.83M
    obj = htole64_internal(obj);
79
3.83M
    s.write(std::as_bytes(std::span{&obj, 1}));
80
3.83M
}
void ser_writedata64<VectorWriter>(VectorWriter&, unsigned long)
Line
Count
Source
77
42.0k
{
78
42.0k
    obj = htole64_internal(obj);
79
42.0k
    s.write(std::as_bytes(std::span{&obj, 1}));
80
42.0k
}
Unexecuted instantiation: void ser_writedata64<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned long)
void ser_writedata64<SizeComputer>(SizeComputer&, unsigned long)
Line
Count
Source
77
440k
{
78
440k
    obj = htole64_internal(obj);
79
440k
    s.write(std::as_bytes(std::span{&obj, 1}));
80
440k
}
void ser_writedata64<HashWriter>(HashWriter&, unsigned long)
Line
Count
Source
77
14.7M
{
78
14.7M
    obj = htole64_internal(obj);
79
14.7M
    s.write(std::as_bytes(std::span{&obj, 1}));
80
14.7M
}
Unexecuted instantiation: void ser_writedata64<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, unsigned long)
Unexecuted instantiation: void ser_writedata64<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, unsigned long)
Unexecuted instantiation: void ser_writedata64<HashedSourceWriter<DataStream>>(HashedSourceWriter<DataStream>&, unsigned long)
Unexecuted instantiation: void ser_writedata64<ParamsStream<VectorWriter&, CNetAddr::SerParams>>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, unsigned long)
void ser_writedata64<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, unsigned long)
Line
Count
Source
77
50.3k
{
78
50.3k
    obj = htole64_internal(obj);
79
50.3k
    s.write(std::as_bytes(std::span{&obj, 1}));
80
50.3k
}
Unexecuted instantiation: void ser_writedata64<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long)
Unexecuted instantiation: void ser_writedata64<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long)
Unexecuted instantiation: void ser_writedata64<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&, unsigned long)
void ser_writedata64<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, unsigned long)
Line
Count
Source
77
381k
{
78
381k
    obj = htole64_internal(obj);
79
381k
    s.write(std::as_bytes(std::span{&obj, 1}));
80
381k
}
void ser_writedata64<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, unsigned long)
Line
Count
Source
77
1.87k
{
78
1.87k
    obj = htole64_internal(obj);
79
1.87k
    s.write(std::as_bytes(std::span{&obj, 1}));
80
1.87k
}
81
template<typename Stream> inline uint8_t ser_readdata8(Stream &s)
82
12.4M
{
83
12.4M
    uint8_t obj;
84
12.4M
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
12.4M
    return obj;
86
12.4M
}
unsigned char ser_readdata8<DataStream>(DataStream&)
Line
Count
Source
82
4.41M
{
83
4.41M
    uint8_t obj;
84
4.41M
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
4.41M
    return obj;
86
4.41M
}
unsigned char ser_readdata8<SpanReader>(SpanReader&)
Line
Count
Source
82
2.32M
{
83
2.32M
    uint8_t obj;
84
2.32M
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
2.32M
    return obj;
86
2.32M
}
unsigned char ser_readdata8<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
82
1.13M
{
83
1.13M
    uint8_t obj;
84
1.13M
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
1.13M
    return obj;
86
1.13M
}
unsigned char ser_readdata8<AutoFile>(AutoFile&)
Line
Count
Source
82
148k
{
83
148k
    uint8_t obj;
84
148k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
148k
    return obj;
86
148k
}
unsigned char ser_readdata8<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
82
1.16k
{
83
1.16k
    uint8_t obj;
84
1.16k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
1.16k
    return obj;
86
1.16k
}
unsigned char ser_readdata8<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&)
Line
Count
Source
82
6
{
83
6
    uint8_t obj;
84
6
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
6
    return obj;
86
6
}
unsigned char ser_readdata8<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
82
6
{
83
6
    uint8_t obj;
84
6
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
6
    return obj;
86
6
}
unsigned char ser_readdata8<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
82
4.06M
{
83
4.06M
    uint8_t obj;
84
4.06M
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
4.06M
    return obj;
86
4.06M
}
unsigned char ser_readdata8<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>>(ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&)
Line
Count
Source
82
2
{
83
2
    uint8_t obj;
84
2
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
2
    return obj;
86
2
}
unsigned char ser_readdata8<ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>>(ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>&)
Line
Count
Source
82
1
{
83
1
    uint8_t obj;
84
1
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
1
    return obj;
86
1
}
unsigned char ser_readdata8<ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>>(ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>&)
Line
Count
Source
82
1
{
83
1
    uint8_t obj;
84
1
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
1
    return obj;
86
1
}
unsigned char ser_readdata8<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&)
Line
Count
Source
82
5
{
83
5
    uint8_t obj;
84
5
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
5
    return obj;
86
5
}
Unexecuted instantiation: unsigned char ser_readdata8<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&)
unsigned char ser_readdata8<BufferedFile>(BufferedFile&)
Line
Count
Source
82
671
{
83
671
    uint8_t obj;
84
671
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
671
    return obj;
86
671
}
unsigned char ser_readdata8<HashVerifier<DataStream>>(HashVerifier<DataStream>&)
Line
Count
Source
82
1
{
83
1
    uint8_t obj;
84
1
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
1
    return obj;
86
1
}
unsigned char ser_readdata8<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
Line
Count
Source
82
62.2k
{
83
62.2k
    uint8_t obj;
84
62.2k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
62.2k
    return obj;
86
62.2k
}
unsigned char ser_readdata8<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
82
41.0k
{
83
41.0k
    uint8_t obj;
84
41.0k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
41.0k
    return obj;
86
41.0k
}
Unexecuted instantiation: unsigned char ser_readdata8<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&)
Unexecuted instantiation: unsigned char ser_readdata8<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&)
unsigned char ser_readdata8<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
82
2.07k
{
83
2.07k
    uint8_t obj;
84
2.07k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
2.07k
    return obj;
86
2.07k
}
unsigned char ser_readdata8<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&)
Line
Count
Source
82
11
{
83
11
    uint8_t obj;
84
11
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
11
    return obj;
86
11
}
unsigned char ser_readdata8<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
82
6
{
83
6
    uint8_t obj;
84
6
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
6
    return obj;
86
6
}
unsigned char ser_readdata8<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&)
Line
Count
Source
82
4.64k
{
83
4.64k
    uint8_t obj;
84
4.64k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
4.64k
    return obj;
86
4.64k
}
Unexecuted instantiation: unsigned char ser_readdata8<ParamsStream<SpanReader, CAddress::SerParams>>(ParamsStream<SpanReader, CAddress::SerParams>&)
Unexecuted instantiation: unsigned char ser_readdata8<ParamsStream<DataStream&, CNetAddr::SerParams>>(ParamsStream<DataStream&, CNetAddr::SerParams>&)
unsigned char ser_readdata8<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
82
262k
{
83
262k
    uint8_t obj;
84
262k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
262k
    return obj;
86
262k
}
unsigned char ser_readdata8<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
82
19.8k
{
83
19.8k
    uint8_t obj;
84
19.8k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
85
19.8k
    return obj;
86
19.8k
}
87
template<typename Stream> inline uint16_t ser_readdata16(Stream &s)
88
20.4k
{
89
20.4k
    uint16_t obj;
90
20.4k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
91
20.4k
    return le16toh_internal(obj);
92
20.4k
}
unsigned short ser_readdata16<SpanReader>(SpanReader&)
Line
Count
Source
88
274
{
89
274
    uint16_t obj;
90
274
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
91
274
    return le16toh_internal(obj);
92
274
}
unsigned short ser_readdata16<DataStream>(DataStream&)
Line
Count
Source
88
523
{
89
523
    uint16_t obj;
90
523
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
91
523
    return le16toh_internal(obj);
92
523
}
unsigned short ser_readdata16<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
88
277
{
89
277
    uint16_t obj;
90
277
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
91
277
    return le16toh_internal(obj);
92
277
}
unsigned short ser_readdata16<AutoFile>(AutoFile&)
Line
Count
Source
88
9.02k
{
89
9.02k
    uint16_t obj;
90
9.02k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
91
9.02k
    return le16toh_internal(obj);
92
9.02k
}
unsigned short ser_readdata16<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
88
9
{
89
9
    uint16_t obj;
90
9
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
91
9
    return le16toh_internal(obj);
92
9
}
unsigned short ser_readdata16<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&)
Line
Count
Source
88
1
{
89
1
    uint16_t obj;
90
1
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
91
1
    return le16toh_internal(obj);
92
1
}
Unexecuted instantiation: unsigned short ser_readdata16<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&)
unsigned short ser_readdata16<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
88
10.3k
{
89
10.3k
    uint16_t obj;
90
10.3k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
91
10.3k
    return le16toh_internal(obj);
92
10.3k
}
Unexecuted instantiation: unsigned short ser_readdata16<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&)
Unexecuted instantiation: unsigned short ser_readdata16<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&)
Unexecuted instantiation: unsigned short ser_readdata16<HashVerifier<DataStream>>(HashVerifier<DataStream>&)
unsigned short ser_readdata16<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
Line
Count
Source
88
20
{
89
20
    uint16_t obj;
90
20
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
91
20
    return le16toh_internal(obj);
92
20
}
Unexecuted instantiation: unsigned short ser_readdata16<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Unexecuted instantiation: unsigned short ser_readdata16<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&)
Unexecuted instantiation: unsigned short ser_readdata16<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&)
unsigned short ser_readdata16<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
88
1
{
89
1
    uint16_t obj;
90
1
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
91
1
    return le16toh_internal(obj);
92
1
}
Unexecuted instantiation: unsigned short ser_readdata16<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&)
Unexecuted instantiation: unsigned short ser_readdata16<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
unsigned short ser_readdata16<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&)
Line
Count
Source
88
13
{
89
13
    uint16_t obj;
90
13
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
91
13
    return le16toh_internal(obj);
92
13
}
Unexecuted instantiation: unsigned short ser_readdata16<ParamsStream<SpanReader, CAddress::SerParams>>(ParamsStream<SpanReader, CAddress::SerParams>&)
Unexecuted instantiation: unsigned short ser_readdata16<ParamsStream<DataStream&, CNetAddr::SerParams>>(ParamsStream<DataStream&, CNetAddr::SerParams>&)
unsigned short ser_readdata16<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
88
5
{
89
5
    uint16_t obj;
90
5
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
91
5
    return le16toh_internal(obj);
92
5
}
Unexecuted instantiation: unsigned short ser_readdata16<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
93
template<typename Stream> inline uint32_t ser_readdata32(Stream &s)
94
6.21M
{
95
6.21M
    uint32_t obj;
96
6.21M
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
6.21M
    return le32toh_internal(obj);
98
6.21M
}
unsigned int ser_readdata32<SpanReader>(SpanReader&)
Line
Count
Source
94
46.6k
{
95
46.6k
    uint32_t obj;
96
46.6k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
46.6k
    return le32toh_internal(obj);
98
46.6k
}
unsigned int ser_readdata32<DataStream>(DataStream&)
Line
Count
Source
94
2.88M
{
95
2.88M
    uint32_t obj;
96
2.88M
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
2.88M
    return le32toh_internal(obj);
98
2.88M
}
unsigned int ser_readdata32<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
94
642k
{
95
642k
    uint32_t obj;
96
642k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
642k
    return le32toh_internal(obj);
98
642k
}
unsigned int ser_readdata32<AutoFile>(AutoFile&)
Line
Count
Source
94
155k
{
95
155k
    uint32_t obj;
96
155k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
155k
    return le32toh_internal(obj);
98
155k
}
unsigned int ser_readdata32<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
94
13.1k
{
95
13.1k
    uint32_t obj;
96
13.1k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
13.1k
    return le32toh_internal(obj);
98
13.1k
}
unsigned int ser_readdata32<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&)
Line
Count
Source
94
7
{
95
7
    uint32_t obj;
96
7
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
7
    return le32toh_internal(obj);
98
7
}
Unexecuted instantiation: unsigned int ser_readdata32<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&)
unsigned int ser_readdata32<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
94
1.71M
{
95
1.71M
    uint32_t obj;
96
1.71M
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
1.71M
    return le32toh_internal(obj);
98
1.71M
}
Unexecuted instantiation: unsigned int ser_readdata32<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&)
Unexecuted instantiation: unsigned int ser_readdata32<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&)
unsigned int ser_readdata32<BufferedReader<AutoFile>>(BufferedReader<AutoFile>&)
Line
Count
Source
94
2
{
95
2
    uint32_t obj;
96
2
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
2
    return le32toh_internal(obj);
98
2
}
Unexecuted instantiation: unsigned int ser_readdata32<HashVerifier<DataStream>>(HashVerifier<DataStream>&)
unsigned int ser_readdata32<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
Line
Count
Source
94
732k
{
95
732k
    uint32_t obj;
96
732k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
732k
    return le32toh_internal(obj);
98
732k
}
Unexecuted instantiation: unsigned int ser_readdata32<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Unexecuted instantiation: unsigned int ser_readdata32<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&)
Unexecuted instantiation: unsigned int ser_readdata32<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Unexecuted instantiation: unsigned int ser_readdata32<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&)
unsigned int ser_readdata32<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&)
Line
Count
Source
94
1.04k
{
95
1.04k
    uint32_t obj;
96
1.04k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
1.04k
    return le32toh_internal(obj);
98
1.04k
}
Unexecuted instantiation: unsigned int ser_readdata32<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
unsigned int ser_readdata32<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&)
Line
Count
Source
94
2.15k
{
95
2.15k
    uint32_t obj;
96
2.15k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
2.15k
    return le32toh_internal(obj);
98
2.15k
}
Unexecuted instantiation: unsigned int ser_readdata32<ParamsStream<SpanReader, CAddress::SerParams>>(ParamsStream<SpanReader, CAddress::SerParams>&)
Unexecuted instantiation: unsigned int ser_readdata32<ParamsStream<DataStream&, CNetAddr::SerParams>>(ParamsStream<DataStream&, CNetAddr::SerParams>&)
Unexecuted instantiation: unsigned int ser_readdata32<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
unsigned int ser_readdata32<BufferedFile>(BufferedFile&)
Line
Count
Source
94
10.1k
{
95
10.1k
    uint32_t obj;
96
10.1k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
10.1k
    return le32toh_internal(obj);
98
10.1k
}
unsigned int ser_readdata32<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
94
15.7k
{
95
15.7k
    uint32_t obj;
96
15.7k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
97
15.7k
    return le32toh_internal(obj);
98
15.7k
}
99
template<typename Stream> inline uint32_t ser_readdata32be(Stream &s)
100
3.09k
{
101
3.09k
    uint32_t obj;
102
3.09k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
103
3.09k
    return be32toh_internal(obj);
104
3.09k
}
105
template<typename Stream> inline uint64_t ser_readdata64(Stream &s)
106
23.3M
{
107
23.3M
    uint64_t obj;
108
23.3M
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
109
23.3M
    return le64toh_internal(obj);
110
23.3M
}
unsigned long ser_readdata64<SpanReader>(SpanReader&)
Line
Count
Source
106
12.8k
{
107
12.8k
    uint64_t obj;
108
12.8k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
109
12.8k
    return le64toh_internal(obj);
110
12.8k
}
unsigned long ser_readdata64<DataStream>(DataStream&)
Line
Count
Source
106
49.4k
{
107
49.4k
    uint64_t obj;
108
49.4k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
109
49.4k
    return le64toh_internal(obj);
110
49.4k
}
unsigned long ser_readdata64<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
106
289k
{
107
289k
    uint64_t obj;
108
289k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
109
289k
    return le64toh_internal(obj);
110
289k
}
unsigned long ser_readdata64<AutoFile>(AutoFile&)
Line
Count
Source
106
22.4M
{
107
22.4M
    uint64_t obj;
108
22.4M
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
109
22.4M
    return le64toh_internal(obj);
110
22.4M
}
unsigned long ser_readdata64<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
106
17
{
107
17
    uint64_t obj;
108
17
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
109
17
    return le64toh_internal(obj);
110
17
}
Unexecuted instantiation: unsigned long ser_readdata64<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&)
Unexecuted instantiation: unsigned long ser_readdata64<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&)
unsigned long ser_readdata64<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
106
521k
{
107
521k
    uint64_t obj;
108
521k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
109
521k
    return le64toh_internal(obj);
110
521k
}
Unexecuted instantiation: unsigned long ser_readdata64<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&)
Unexecuted instantiation: unsigned long ser_readdata64<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&)
Unexecuted instantiation: unsigned long ser_readdata64<HashVerifier<DataStream>>(HashVerifier<DataStream>&)
unsigned long ser_readdata64<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
Line
Count
Source
106
20.5k
{
107
20.5k
    uint64_t obj;
108
20.5k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
109
20.5k
    return le64toh_internal(obj);
110
20.5k
}
Unexecuted instantiation: unsigned long ser_readdata64<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Unexecuted instantiation: unsigned long ser_readdata64<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&)
Unexecuted instantiation: unsigned long ser_readdata64<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Unexecuted instantiation: unsigned long ser_readdata64<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&)
unsigned long ser_readdata64<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&)
Line
Count
Source
106
4
{
107
4
    uint64_t obj;
108
4
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
109
4
    return le64toh_internal(obj);
110
4
}
Unexecuted instantiation: unsigned long ser_readdata64<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
unsigned long ser_readdata64<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&)
Line
Count
Source
106
832
{
107
832
    uint64_t obj;
108
832
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
109
832
    return le64toh_internal(obj);
110
832
}
Unexecuted instantiation: unsigned long ser_readdata64<ParamsStream<SpanReader, CAddress::SerParams>>(ParamsStream<SpanReader, CAddress::SerParams>&)
Unexecuted instantiation: unsigned long ser_readdata64<ParamsStream<DataStream&, CNetAddr::SerParams>>(ParamsStream<DataStream&, CNetAddr::SerParams>&)
Unexecuted instantiation: unsigned long ser_readdata64<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
unsigned long ser_readdata64<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
106
3.96k
{
107
3.96k
    uint64_t obj;
108
3.96k
    s.read(std::as_writable_bytes(std::span{&obj, 1}));
109
3.96k
    return le64toh_internal(obj);
110
3.96k
}
111
112
113
class SizeComputer;
114
115
/**
116
 * Convert any argument to a reference to X, maintaining constness.
117
 *
118
 * This can be used in serialization code to invoke a base class's
119
 * serialization routines.
120
 *
121
 * Example use:
122
 *   class Base { ... };
123
 *   class Child : public Base {
124
 *     int m_data;
125
 *   public:
126
 *     SERIALIZE_METHODS(Child, obj) {
127
 *       READWRITE(AsBase<Base>(obj), obj.m_data);
128
 *     }
129
 *   };
130
 *
131
 * static_cast cannot easily be used here, as the type of Obj will be const Child&
132
 * during serialization and Child& during deserialization. AsBase will convert to
133
 * const Base& and Base& appropriately.
134
 */
135
template <class Out, class In>
136
Out& AsBase(In& x)
137
1.55M
{
138
1.55M
    static_assert(std::is_base_of_v<Out, In>);
139
1.55M
    return x;
140
1.55M
}
prevector<36u, unsigned char, unsigned int, int>& AsBase<prevector<36u, unsigned char, unsigned int, int>, CScript>(CScript&)
Line
Count
Source
137
1.30M
{
138
1.30M
    static_assert(std::is_base_of_v<Out, In>);
139
1.30M
    return x;
140
1.30M
}
CBlockHeader& AsBase<CBlockHeader, CBlock>(CBlock&)
Line
Count
Source
137
176k
{
138
176k
    static_assert(std::is_base_of_v<Out, In>);
139
176k
    return x;
140
176k
}
CNetAddr& AsBase<CNetAddr, CService>(CService&)
Line
Count
Source
137
29.2k
{
138
29.2k
    static_assert(std::is_base_of_v<Out, In>);
139
29.2k
    return x;
140
29.2k
}
CService& AsBase<CService, CAddress>(CAddress&)
Line
Count
Source
137
27.4k
{
138
27.4k
    static_assert(std::is_base_of_v<Out, In>);
139
27.4k
    return x;
140
27.4k
}
CAddress& AsBase<CAddress, AddrInfo>(AddrInfo&)
Line
Count
Source
137
20.5k
{
138
20.5k
    static_assert(std::is_base_of_v<Out, In>);
139
20.5k
    return x;
140
20.5k
}
FlatFilePos& AsBase<FlatFilePos, CDiskTxPos>(CDiskTxPos&)
Line
Count
Source
137
29
{
138
29
    static_assert(std::is_base_of_v<Out, In>);
139
29
    return x;
140
29
}
141
template <class Out, class In>
142
const Out& AsBase(const In& x)
143
35.7M
{
144
35.7M
    static_assert(std::is_base_of_v<Out, In>);
145
35.7M
    return x;
146
35.7M
}
prevector<36u, unsigned char, unsigned int, int> const& AsBase<prevector<36u, unsigned char, unsigned int, int>, CScript>(CScript const&)
Line
Count
Source
143
34.6M
{
144
34.6M
    static_assert(std::is_base_of_v<Out, In>);
145
34.6M
    return x;
146
34.6M
}
CBlockHeader const& AsBase<CBlockHeader, CBlock>(CBlock const&)
Line
Count
Source
143
848k
{
144
848k
    static_assert(std::is_base_of_v<Out, In>);
145
848k
    return x;
146
848k
}
CNetAddr const& AsBase<CNetAddr, CService>(CService const&)
Line
Count
Source
143
72.8k
{
144
72.8k
    static_assert(std::is_base_of_v<Out, In>);
145
72.8k
    return x;
146
72.8k
}
CService const& AsBase<CService, CAddress>(CAddress const&)
Line
Count
Source
143
69.3k
{
144
69.3k
    static_assert(std::is_base_of_v<Out, In>);
145
69.3k
    return x;
146
69.3k
}
CAddress const& AsBase<CAddress, AddrInfo>(AddrInfo const&)
Line
Count
Source
143
50.3k
{
144
50.3k
    static_assert(std::is_base_of_v<Out, In>);
145
50.3k
    return x;
146
50.3k
}
serialize_tests::Base const& AsBase<serialize_tests::Base, serialize_tests::Derived>(serialize_tests::Derived const&)
Line
Count
Source
143
2
{
144
2
    static_assert(std::is_base_of_v<Out, In>);
145
2
    return x;
146
2
}
FlatFilePos const& AsBase<FlatFilePos, CDiskTxPos>(CDiskTxPos const&)
Line
Count
Source
143
46
{
144
46
    static_assert(std::is_base_of_v<Out, In>);
145
46
    return x;
146
46
}
147
148
133M
#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__))
149
86.4k
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
void CAddress::SerializationOps<ParamsStream<SpanReader&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<SpanReader&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<SpanReader&, CAddress::SerParams>&, CAddress&)::operator()(ParamsStream<SpanReader&, CAddress::SerParams>&, CAddress&) const
Line
Count
Source
149
3
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
void CPartialMerkleTree::SerializationOps<DataStream, CPartialMerkleTree, ActionUnserialize>(CPartialMerkleTree&, DataStream&, ActionUnserialize)::'lambda'(DataStream&, CPartialMerkleTree&)::operator()(DataStream&, CPartialMerkleTree&) const
Line
Count
Source
149
168
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
void CPartialMerkleTree::SerializationOps<DataStream, CPartialMerkleTree, ActionUnserialize>(CPartialMerkleTree&, DataStream&, ActionUnserialize)::'lambda0'(DataStream&, CPartialMerkleTree&)::operator()(DataStream&, CPartialMerkleTree&) const
Line
Count
Source
149
168
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
void CAddress::SerializationOps<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CAddress&)::operator()(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CAddress&) const
Line
Count
Source
149
20.5k
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
Unexecuted instantiation: void CAddress::SerializationOps<ParamsStream<AutoFile&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<AutoFile&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<AutoFile&, CAddress::SerParams>&, CAddress&)::operator()(ParamsStream<AutoFile&, CAddress::SerParams>&, CAddress&) const
void CAddress::SerializationOps<ParamsStream<DataStream&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<DataStream&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress&)::operator()(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress&) const
Line
Count
Source
149
1.03k
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
void CAddress::SerializationOps<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CAddress&)::operator()(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CAddress&) const
Line
Count
Source
149
3
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
coinstatsindex.cpp:void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, DataStream&, ActionUnserialize)::'lambda'(DataStream&, (anonymous namespace)::DBVal&)::operator()(DataStream&, (anonymous namespace)::DBVal&) const
Line
Count
Source
149
121
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
coinstatsindex.cpp:void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, DataStream&, ActionUnserialize)::'lambda0'(DataStream&, (anonymous namespace)::DBVal&)::operator()(DataStream&, (anonymous namespace)::DBVal&) const
Line
Count
Source
149
121
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
coinstatsindex.cpp:void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, DataStream&, ActionUnserialize)::'lambda1'(DataStream&, (anonymous namespace)::DBVal&)::operator()(DataStream&, (anonymous namespace)::DBVal&) const
Line
Count
Source
149
121
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
coinstatsindex.cpp:void (anonymous namespace)::DBVal::SerializationOps<SpanReader, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, SpanReader&, ActionUnserialize)::'lambda'(SpanReader&, (anonymous namespace)::DBVal&)::operator()(SpanReader&, (anonymous namespace)::DBVal&) const
Line
Count
Source
149
224
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
coinstatsindex.cpp:void (anonymous namespace)::DBVal::SerializationOps<SpanReader, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, SpanReader&, ActionUnserialize)::'lambda0'(SpanReader&, (anonymous namespace)::DBVal&)::operator()(SpanReader&, (anonymous namespace)::DBVal&) const
Line
Count
Source
149
224
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
coinstatsindex.cpp:void (anonymous namespace)::DBVal::SerializationOps<SpanReader, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, SpanReader&, ActionUnserialize)::'lambda1'(SpanReader&, (anonymous namespace)::DBVal&)::operator()(SpanReader&, (anonymous namespace)::DBVal&) const
Line
Count
Source
149
224
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
void CPartialMerkleTree::SerializationOps<SpanReader, CPartialMerkleTree, ActionUnserialize>(CPartialMerkleTree&, SpanReader&, ActionUnserialize)::'lambda'(SpanReader&, CPartialMerkleTree&)::operator()(SpanReader&, CPartialMerkleTree&) const
Line
Count
Source
149
20
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
void CPartialMerkleTree::SerializationOps<SpanReader, CPartialMerkleTree, ActionUnserialize>(CPartialMerkleTree&, SpanReader&, ActionUnserialize)::'lambda0'(SpanReader&, CPartialMerkleTree&)::operator()(SpanReader&, CPartialMerkleTree&) const
Line
Count
Source
149
20
#define SER_READ(obj, code) ser_action.SerRead(s, obj, [&](Stream& s, std::remove_const_t<Type>& obj) { code; })
150
86.0k
#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
void CAddress::SerializationOps<ParamsStream<DataStream&, CAddress::SerParams>, CAddress const, ActionSerialize>(CAddress const&, ParamsStream<DataStream&, CAddress::SerParams>&, ActionSerialize)::'lambda'(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress const&)::operator()(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress const&) const
Line
Count
Source
150
18
#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
void CPartialMerkleTree::SerializationOps<DataStream, CPartialMerkleTree const, ActionSerialize>(CPartialMerkleTree const&, DataStream&, ActionSerialize)::'lambda'(DataStream&, CPartialMerkleTree const&)::operator()(DataStream&, CPartialMerkleTree const&) const
Line
Count
Source
150
182
#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
void CAddress::SerializationOps<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, CAddress const, ActionSerialize>(CAddress const&, ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, ActionSerialize)::'lambda'(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CAddress const&)::operator()(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CAddress const&) const
Line
Count
Source
150
50.3k
#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
coinstatsindex.cpp:void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal const, ActionSerialize>((anonymous namespace)::DBVal const&, DataStream&, ActionSerialize)::'lambda'(DataStream&, (anonymous namespace)::DBVal const&)::operator()(DataStream&, (anonymous namespace)::DBVal const&) const
Line
Count
Source
150
4.22k
#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
coinstatsindex.cpp:void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal const, ActionSerialize>((anonymous namespace)::DBVal const&, DataStream&, ActionSerialize)::'lambda0'(DataStream&, (anonymous namespace)::DBVal const&)::operator()(DataStream&, (anonymous namespace)::DBVal const&) const
Line
Count
Source
150
4.22k
#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
coinstatsindex.cpp:void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal const, ActionSerialize>((anonymous namespace)::DBVal const&, DataStream&, ActionSerialize)::'lambda1'(DataStream&, (anonymous namespace)::DBVal const&)::operator()(DataStream&, (anonymous namespace)::DBVal const&) const
Line
Count
Source
150
4.22k
#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
void CPartialMerkleTree::SerializationOps<VectorWriter, CPartialMerkleTree const, ActionSerialize>(CPartialMerkleTree const&, VectorWriter&, ActionSerialize)::'lambda'(VectorWriter&, CPartialMerkleTree const&)::operator()(VectorWriter&, CPartialMerkleTree const&) const
Line
Count
Source
150
4
#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
void CAddress::SerializationOps<ParamsStream<VectorWriter&, CAddress::SerParams>, CAddress const, ActionSerialize>(CAddress const&, ParamsStream<VectorWriter&, CAddress::SerParams>&, ActionSerialize)::'lambda'(ParamsStream<VectorWriter&, CAddress::SerParams>&, CAddress const&)::operator()(ParamsStream<VectorWriter&, CAddress::SerParams>&, CAddress const&) const
Line
Count
Source
150
33
#define SER_WRITE(obj, code) ser_action.SerWrite(s, obj, [&](Stream& s, const Type& obj) { code; })
151
152
/**
153
 * Implement the Ser and Unser methods needed for implementing a formatter (see Using below).
154
 *
155
 * Both Ser and Unser are delegated to a single static method SerializationOps, which is polymorphic
156
 * in the serialized/deserialized type (allowing it to be const when serializing, and non-const when
157
 * deserializing).
158
 *
159
 * Example use:
160
 *   struct FooFormatter {
161
 *     FORMATTER_METHODS(Class, obj) { READWRITE(obj.val1, VARINT(obj.val2)); }
162
 *   }
163
 *   would define a class FooFormatter that defines a serialization of Class objects consisting
164
 *   of serializing its val1 member using the default serialization, and its val2 member using
165
 *   VARINT serialization. That FooFormatter can then be used in statements like
166
 *   READWRITE(Using<FooFormatter>(obj.bla)).
167
 */
168
#define FORMATTER_METHODS(cls, obj) \
169
    template<typename Stream> \
170
124M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxIn::Ser<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, CTxIn const&)
Line
Count
Source
170
4.47M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CScript::Ser<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, CScript const&)
Line
Count
Source
170
11.6M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void COutPoint::Ser<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, COutPoint const&)
Line
Count
Source
170
4.47M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxOut::Ser<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, CTxOut const&)
Line
Count
Source
170
7.16M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlock::Ser<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, CBlock const&)
Line
Count
Source
170
710k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockHeader::Ser<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, CBlockHeader const&)
Line
Count
Source
170
710k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void AddrInfo::Ser<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, AddrInfo const&)
Line
Count
Source
170
17
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CAddress::Ser<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress const&)
Line
Count
Source
170
23
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CService::Ser<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, CService const&)
Line
Count
Source
170
23
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockHeaderAndShortTxIDs::Ser<DataStream>(DataStream&, CBlockHeaderAndShortTxIDs const&)
Line
Count
Source
170
4
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockHeader::Ser<DataStream>(DataStream&, CBlockHeader const&)
Line
Count
Source
170
97.0k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void PrefilledTransaction::Ser<DataStream>(DataStream&, PrefilledTransaction const&)
Line
Count
Source
170
11
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxIn::Ser<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, CTxIn const&)
Line
Count
Source
170
125k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void COutPoint::Ser<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, COutPoint const&)
Line
Count
Source
170
125k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CScript::Ser<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, CScript const&)
Line
Count
Source
170
393k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxOut::Ser<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, CTxOut const&)
Line
Count
Source
170
267k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void blockencodings_tests::TestHeaderAndShortIDs::Ser<DataStream>(DataStream&, blockencodings_tests::TestHeaderAndShortIDs const&)
Line
Count
Source
170
5
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void BlockTransactionsRequest::Ser<DataStream>(DataStream&, BlockTransactionsRequest const&)
Line
Count
Source
170
2
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBloomFilter::Ser<DataStream>(DataStream&, CBloomFilter const&)
Line
Count
Source
170
3
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CMerkleBlock::Ser<DataStream>(DataStream&, CMerkleBlock const&)
Line
Count
Source
170
14
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CPartialMerkleTree::Ser<DataStream>(DataStream&, CPartialMerkleTree const&)
Line
Count
Source
170
182
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void MuHash3072::Ser<DataStream>(DataStream&, MuHash3072 const&)
Line
Count
Source
170
120
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void Num3072::Ser<DataStream>(DataStream&, Num3072 const&)
Line
Count
Source
170
240
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxIn::Ser<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, CTxIn const&)
Line
Count
Source
170
69.5k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void COutPoint::Ser<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, COutPoint const&)
Line
Count
Source
170
69.5k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CScript::Ser<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, CScript const&)
Line
Count
Source
170
240k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxOut::Ser<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, CTxOut const&)
Line
Count
Source
170
170k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxIn::Ser<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&, CTxIn const&)
Line
Count
Source
170
2.10M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void COutPoint::Ser<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&, COutPoint const&)
Line
Count
Source
170
2.10M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CScript::Ser<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&, CScript const&)
Line
Count
Source
170
5.94M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxOut::Ser<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&, CTxOut const&)
Line
Count
Source
170
3.83M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CMessageHeader::Ser<DataStream>(DataStream&, CMessageHeader const&)
Line
Count
Source
170
2
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CService::Ser<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, CService const&)
Line
Count
Source
170
1
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void serialize_tests::CSerializeMethodsTestSingle::Ser<DataStream>(DataStream&, serialize_tests::CSerializeMethodsTestSingle const&)
Line
Count
Source
170
1
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void serialize_tests::CSerializeMethodsTestMany::Ser<DataStream>(DataStream&, serialize_tests::CSerializeMethodsTestMany const&)
Line
Count
Source
170
1
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void serialize_tests::Derived::Ser<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::Derived const&)
Line
Count
Source
170
2
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void txindex::BlockTxPosition::Ser<DataStream>(DataStream&, txindex::BlockTxPosition const&)
Line
Count
Source
170
4.58k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void txindex::BlockSeqKey::Ser<DataStream>(DataStream&, txindex::BlockSeqKey const&)
Line
Count
Source
170
4.31k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void txindex::DBKey::Ser<DataStream>(DataStream&, txindex::DBKey const&)
Line
Count
Source
170
4.57k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockHeader::Ser<SizeComputer>(SizeComputer&, CBlockHeader const&)
Line
Count
Source
170
35.6k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CDiskTxPos::Ser<DataStream>(DataStream&, CDiskTxPos const&)
Line
Count
Source
170
46
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void FlatFilePos::Ser<DataStream>(DataStream&, FlatFilePos const&)
Line
Count
Source
170
8.33k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockLocator::Ser<DataStream>(DataStream&, CBlockLocator const&)
Line
Count
Source
170
25.7k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxOut::Ser<SizeComputer>(SizeComputer&, CTxOut const&)
Line
Count
Source
170
402k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CScript::Ser<SizeComputer>(SizeComputer&, CScript const&)
Line
Count
Source
170
402k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxOut::Ser<DataStream>(DataStream&, CTxOut const&)
Line
Count
Source
170
7.45k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CScript::Ser<DataStream>(DataStream&, CScript const&)
Line
Count
Source
170
10.0k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void XOnlyPubKey::Ser<SizeComputer>(SizeComputer&, XOnlyPubKey const&)
Line
Count
Source
170
5.96k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void XOnlyPubKey::Ser<DataStream>(DataStream&, XOnlyPubKey const&)
Line
Count
Source
170
5.96k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CService::Ser<ParamsStream<VectorWriter&, CNetAddr::SerParams>>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, CService const&)
Line
Count
Source
170
3.48k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CAddress::Ser<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CAddress const&)
Line
Count
Source
170
50.3k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CService::Ser<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, CService const&)
Line
Count
Source
170
50.3k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void AddrInfo::Ser<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, AddrInfo const&)
Line
Count
Source
170
50.3k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockHeaderAndShortTxIDs::Ser<SizeComputer>(SizeComputer&, CBlockHeaderAndShortTxIDs const&)
Line
Count
Source
170
35.6k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void PrefilledTransaction::Ser<SizeComputer>(SizeComputer&, PrefilledTransaction const&)
Line
Count
Source
170
35.7k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void index_util::DBHashKey::Ser<DataStream>(DataStream&, index_util::DBHashKey const&)
Line
Count
Source
170
268
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
blockfilterindex.cpp:void (anonymous namespace)::DBVal::Ser<DataStream>(DataStream&, (anonymous namespace)::DBVal const&)
Line
Count
Source
170
8.11k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
coinstatsindex.cpp:void (anonymous namespace)::DBVal::Ser<DataStream>(DataStream&, (anonymous namespace)::DBVal const&)
Line
Count
Source
170
4.22k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void txindex::BlockHashKey::Ser<DataStream>(DataStream&, txindex::BlockHashKey const&)
Line
Count
Source
170
8.81k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void DBKey::Ser<DataStream>(DataStream&, DBKey const&)
Line
Count
Source
170
44
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void COutPoint::Ser<HashWriter>(HashWriter&, COutPoint const&)
Line
Count
Source
170
21.5M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxOut::Ser<HashWriter>(HashWriter&, CTxOut const&)
Line
Count
Source
170
14.4M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CScript::Ser<HashWriter>(HashWriter&, CScript const&)
Line
Count
Source
170
15.4M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void COutPoint::Ser<DataStream>(DataStream&, COutPoint const&)
Line
Count
Source
170
6.20k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CMessageHeader::Ser<VectorWriter>(VectorWriter&, CMessageHeader const&)
Line
Count
Source
170
136k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockHeaderAndShortTxIDs::Ser<VectorWriter>(VectorWriter&, CBlockHeaderAndShortTxIDs const&)
Line
Count
Source
170
18.8k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockHeader::Ser<VectorWriter>(VectorWriter&, CBlockHeader const&)
Line
Count
Source
170
18.8k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void PrefilledTransaction::Ser<VectorWriter>(VectorWriter&, PrefilledTransaction const&)
Line
Count
Source
170
18.8k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CInv::Ser<VectorWriter>(VectorWriter&, CInv const&)
Line
Count
Source
170
84.8k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlock::Ser<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, CBlock const&)
Line
Count
Source
170
35.0k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockHeader::Ser<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, CBlockHeader const&)
Line
Count
Source
170
35.0k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CMerkleBlock::Ser<VectorWriter>(VectorWriter&, CMerkleBlock const&)
Line
Count
Source
170
4
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CPartialMerkleTree::Ser<VectorWriter>(VectorWriter&, CPartialMerkleTree const&)
Line
Count
Source
170
4
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockLocator::Ser<VectorWriter>(VectorWriter&, CBlockLocator const&)
Line
Count
Source
170
3.01k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void BlockTransactions::Ser<VectorWriter>(VectorWriter&, BlockTransactions const&)
Line
Count
Source
170
590
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void BlockTransactionsRequest::Ser<VectorWriter>(VectorWriter&, BlockTransactionsRequest const&)
Line
Count
Source
170
577
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CAddress::Ser<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, CAddress const&)
Line
Count
Source
170
18.9k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CService::Ser<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, CService const&)
Line
Count
Source
170
18.9k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void kernel::CBlockFileInfo::Ser<DataStream>(DataStream&, kernel::CBlockFileInfo const&)
Line
Count
Source
170
1.72k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CDiskBlockIndex::Ser<DataStream>(DataStream&, CDiskBlockIndex const&)
Line
Count
Source
170
117k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockUndo::Ser<SizeComputer>(SizeComputer&, CBlockUndo const&)
Line
Count
Source
170
100k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxUndo::Ser<SizeComputer>(SizeComputer&, CTxUndo const&)
Line
Count
Source
170
45.0k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void TxOutCompression::Ser<SizeComputer>(SizeComputer&, CTxOut const&)
Line
Count
Source
170
69.5k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockUndo::Ser<HashWriter>(HashWriter&, CBlockUndo const&)
Line
Count
Source
170
100k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxUndo::Ser<HashWriter>(HashWriter&, CTxUndo const&)
Line
Count
Source
170
45.0k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void TxOutCompression::Ser<HashWriter>(HashWriter&, CTxOut const&)
Line
Count
Source
170
69.5k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockUndo::Ser<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&, CBlockUndo const&)
Line
Count
Source
170
100k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxUndo::Ser<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&, CTxUndo const&)
Line
Count
Source
170
45.0k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void TxOutCompression::Ser<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&, CTxOut const&)
Line
Count
Source
170
69.5k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlock::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, CBlock const&)
Line
Count
Source
170
102k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockHeader::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, CBlockHeader const&)
Line
Count
Source
170
102k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxIn::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, CTxIn const&)
Line
Count
Source
170
185k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void COutPoint::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, COutPoint const&)
Line
Count
Source
170
185k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CScript::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, CScript const&)
Line
Count
Source
170
567k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxOut::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, CTxOut const&)
Line
Count
Source
170
381k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxIn::Ser<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, CTxIn const&)
Line
Count
Source
170
2.38k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void COutPoint::Ser<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, COutPoint const&)
Line
Count
Source
170
2.38k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CScript::Ser<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, CScript const&)
Line
Count
Source
170
4.25k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CTxOut::Ser<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, CTxOut const&)
Line
Count
Source
170
1.87k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CCoin::Ser<DataStream>(DataStream&, CCoin const&)
Line
Count
Source
170
2
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void TxOutCompression::Ser<AutoFile>(AutoFile&, CTxOut const&)
Line
Count
Source
170
6.58k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlock::Ser<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, CBlock const&)
Line
Count
Source
170
41
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockHeader::Ser<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, CBlockHeader const&)
Line
Count
Source
170
42
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
txdb.cpp:void (anonymous namespace)::CoinEntry::Ser<DataStream>(DataStream&, (anonymous namespace)::CoinEntry const&)
Line
Count
Source
170
5.62M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void TxOutCompression::Ser<DataStream>(DataStream&, CTxOut const&)
Line
Count
Source
170
289k
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void CBlockHeader::Ser<HashWriter>(HashWriter&, CBlockHeader const&)
Line
Count
Source
170
18.6M
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void wallet::CKeyMetadata::Ser<DataStream>(DataStream&, wallet::CKeyMetadata const&)
Line
Count
Source
170
60
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
Unexecuted instantiation: void KeyOriginInfo::Ser<DataStream>(DataStream&, KeyOriginInfo const&)
void wallet::CMasterKey::Ser<DataStream>(DataStream&, wallet::CMasterKey const&)
Line
Count
Source
170
45
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
void COutPoint::Ser<SpanWriter>(SpanWriter&, COutPoint const&)
Line
Count
Source
170
59
    static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \
171
    template<typename Stream> \
172
5.25M
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void blockencodings_tests::TestHeaderAndShortIDs::Unser<DataStream>(DataStream&, blockencodings_tests::TestHeaderAndShortIDs&)
Line
Count
Source
172
2
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlockHeader::Unser<DataStream>(DataStream&, CBlockHeader&)
Line
Count
Source
172
476k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void PrefilledTransaction::Unser<DataStream>(DataStream&, PrefilledTransaction&)
Line
Count
Source
172
21.6k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxIn::Unser<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, CTxIn&)
Line
Count
Source
172
137k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void COutPoint::Unser<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, COutPoint&)
Line
Count
Source
172
137k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CScript::Unser<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, CScript&)
Line
Count
Source
172
426k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxOut::Unser<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, CTxOut&)
Line
Count
Source
172
289k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlockHeaderAndShortTxIDs::Unser<DataStream>(DataStream&, CBlockHeaderAndShortTxIDs&)
Line
Count
Source
172
21.6k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void BlockTransactionsRequest::Unser<DataStream>(DataStream&, BlockTransactionsRequest&)
Line
Count
Source
172
597
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxIn::Unser<DataStream>(DataStream&, CTxIn&)
Line
Count
Source
172
4.79k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void COutPoint::Unser<DataStream>(DataStream&, COutPoint&)
Line
Count
Source
172
4.79k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CScript::Unser<DataStream>(DataStream&, CScript&)
Line
Count
Source
172
9.76k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxOut::Unser<DataStream>(DataStream&, CTxOut&)
Line
Count
Source
172
4.78k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxIn::Unser<SpanReader>(SpanReader&, CTxIn&)
Line
Count
Source
172
1
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void COutPoint::Unser<SpanReader>(SpanReader&, COutPoint&)
Line
Count
Source
172
1
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CScript::Unser<SpanReader>(SpanReader&, CScript&)
Line
Count
Source
172
8.14k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxOut::Unser<SpanReader>(SpanReader&, CTxOut&)
Line
Count
Source
172
4.78k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlock::Unser<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, CBlock&)
Line
Count
Source
172
34.2k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlockHeader::Unser<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, CBlockHeader&)
Line
Count
Source
172
34.2k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void TxOutCompression::Unser<SpanReader>(SpanReader&, CTxOut&)
Line
Count
Source
172
89.6k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void MuHash3072::Unser<DataStream>(DataStream&, MuHash3072&)
Line
Count
Source
172
2
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void Num3072::Unser<DataStream>(DataStream&, Num3072&)
Line
Count
Source
172
4
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CAddress::Unser<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&, CAddress&)
Line
Count
Source
172
7
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CService::Unser<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&, CService&)
Line
Count
Source
172
7
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CPartialMerkleTree::Unser<DataStream>(DataStream&, CPartialMerkleTree&)
Line
Count
Source
172
168
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxIn::Unser<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&, CTxIn&)
Line
Count
Source
172
332k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void COutPoint::Unser<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&, COutPoint&)
Line
Count
Source
172
332k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CScript::Unser<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&, CScript&)
Line
Count
Source
172
853k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxOut::Unser<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&, CTxOut&)
Line
Count
Source
172
521k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void serialize_tests::CSerializeMethodsTestMany::Unser<DataStream>(DataStream&, serialize_tests::CSerializeMethodsTestMany&)
Line
Count
Source
172
1
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void serialize_tests::CSerializeMethodsTestSingle::Unser<DataStream>(DataStream&, serialize_tests::CSerializeMethodsTestSingle&)
Line
Count
Source
172
2
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void txindex::DBKey::Unser<SpanReader>(SpanReader&, txindex::DBKey&)
Line
Count
Source
172
326
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void txindex::BlockTxPosition::Unser<SpanReader>(SpanReader&, txindex::BlockTxPosition&)
Line
Count
Source
172
326
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void txindex::BlockTxPosition::Unser<DataStream>(DataStream&, txindex::BlockTxPosition&)
Line
Count
Source
172
4
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlockLocator::Unser<SpanReader>(SpanReader&, CBlockLocator&)
Line
Count
Source
172
110
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void TxOutCompression::Unser<AutoFile>(AutoFile&, CTxOut&)
Line
Count
Source
172
6.35k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void XOnlyPubKey::Unser<SpanReader>(SpanReader&, XOnlyPubKey&)
Line
Count
Source
172
8.15k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
Unexecuted instantiation: void XOnlyPubKey::Unser<DataStream>(DataStream&, XOnlyPubKey&)
void CAddress::Unser<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CAddress&)
Line
Count
Source
172
20.5k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CService::Unser<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, CService&)
Line
Count
Source
172
20.5k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
Unexecuted instantiation: void AddrInfo::Unser<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&, AddrInfo&)
Unexecuted instantiation: void CAddress::Unser<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&, CAddress&)
Unexecuted instantiation: void CService::Unser<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&, CService&)
void AddrInfo::Unser<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, AddrInfo&)
Line
Count
Source
172
20.5k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void AddrInfo::Unser<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, AddrInfo&)
Line
Count
Source
172
14
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CAddress::Unser<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress&)
Line
Count
Source
172
6.92k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CService::Unser<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, CService&)
Line
Count
Source
172
6.91k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void AddrInfo::Unser<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, AddrInfo&)
Line
Count
Source
172
5
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CAddress::Unser<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CAddress&)
Line
Count
Source
172
5
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CService::Unser<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&, CService&)
Line
Count
Source
172
4
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
blockfilterindex.cpp:void (anonymous namespace)::DBVal::Unser<DataStream>(DataStream&, (anonymous namespace)::DBVal&)
Line
Count
Source
172
2.97k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void FlatFilePos::Unser<DataStream>(DataStream&, FlatFilePos&)
Line
Count
Source
172
2.97k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
blockfilterindex.cpp:void (anonymous namespace)::DBVal::Unser<SpanReader>(SpanReader&, (anonymous namespace)::DBVal&)
Line
Count
Source
172
1.06k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void FlatFilePos::Unser<SpanReader>(SpanReader&, FlatFilePos&)
Line
Count
Source
172
1.12k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
coinstatsindex.cpp:void (anonymous namespace)::DBVal::Unser<DataStream>(DataStream&, (anonymous namespace)::DBVal&)
Line
Count
Source
172
121
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
coinstatsindex.cpp:void (anonymous namespace)::DBVal::Unser<SpanReader>(SpanReader&, (anonymous namespace)::DBVal&)
Line
Count
Source
172
224
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void MuHash3072::Unser<SpanReader>(SpanReader&, MuHash3072&)
Line
Count
Source
172
32
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void Num3072::Unser<SpanReader>(SpanReader&, Num3072&)
Line
Count
Source
172
64
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxIn::Unser<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, CTxIn&)
Line
Count
Source
172
517
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void COutPoint::Unser<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, COutPoint&)
Line
Count
Source
172
517
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CScript::Unser<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, CScript&)
Line
Count
Source
172
1.34k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxOut::Unser<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, CTxOut&)
Line
Count
Source
172
832
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CDiskTxPos::Unser<SpanReader>(SpanReader&, CDiskTxPos&)
Line
Count
Source
172
29
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlockHeader::Unser<AutoFile>(AutoFile&, CBlockHeader&)
Line
Count
Source
172
24
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void DBKey::Unser<SpanReader>(SpanReader&, DBKey&)
Line
Count
Source
172
26
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
Unexecuted instantiation: void CService::Unser<ParamsStream<SpanReader, CAddress::SerParams>>(ParamsStream<SpanReader, CAddress::SerParams>&, CService&)
void CMessageHeader::Unser<DataStream>(DataStream&, CMessageHeader&)
Line
Count
Source
172
129k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CService::Unser<ParamsStream<DataStream&, CNetAddr::SerParams>>(ParamsStream<DataStream&, CNetAddr::SerParams>&, CService&)
Line
Count
Source
172
1.73k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CInv::Unser<DataStream>(DataStream&, CInv&)
Line
Count
Source
172
167k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlockLocator::Unser<DataStream>(DataStream&, CBlockLocator&)
Line
Count
Source
172
5.20k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void BlockTransactions::Unser<DataStream>(DataStream&, BlockTransactions&)
Line
Count
Source
172
572
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBloomFilter::Unser<DataStream>(DataStream&, CBloomFilter&)
Line
Count
Source
172
10
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void kernel::CBlockFileInfo::Unser<SpanReader>(SpanReader&, kernel::CBlockFileInfo&)
Line
Count
Source
172
839
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CDiskBlockIndex::Unser<DataStream>(DataStream&, CDiskBlockIndex&)
Line
Count
Source
172
152k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlockUndo::Unser<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&, CBlockUndo&)
Line
Count
Source
172
33.7k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxUndo::Unser<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&, CTxUndo&)
Line
Count
Source
172
21.0k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void TxOutCompression::Unser<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&, CTxOut&)
Line
Count
Source
172
31.1k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlock::Unser<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&, CBlock&)
Line
Count
Source
172
140k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlockHeader::Unser<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&, CBlockHeader&)
Line
Count
Source
172
140k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CMerkleBlock::Unser<SpanReader>(SpanReader&, CMerkleBlock&)
Line
Count
Source
172
20
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlockHeader::Unser<SpanReader>(SpanReader&, CBlockHeader&)
Line
Count
Source
172
1.86k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CPartialMerkleTree::Unser<SpanReader>(SpanReader&, CPartialMerkleTree&)
Line
Count
Source
172
20
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
txdb.cpp:void (anonymous namespace)::CoinEntry::Unser<SpanReader>(SpanReader&, (anonymous namespace)::CoinEntry&)
Line
Count
Source
172
279k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void TxOutCompression::Unser<DataStream>(DataStream&, CTxOut&)
Line
Count
Source
172
279k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlockHeader::Unser<BufferedFile>(BufferedFile&, CBlockHeader&)
Line
Count
Source
172
2.02k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlock::Unser<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&, CBlock&)
Line
Count
Source
172
1.91k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CBlockHeader::Unser<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&, CBlockHeader&)
Line
Count
Source
172
1.91k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxIn::Unser<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&, CTxIn&)
Line
Count
Source
172
2.01k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void COutPoint::Unser<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&, COutPoint&)
Line
Count
Source
172
2.01k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CScript::Unser<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&, CScript&)
Line
Count
Source
172
5.97k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void CTxOut::Unser<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&, CTxOut&)
Line
Count
Source
172
3.96k
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void wallet::CKeyMetadata::Unser<DataStream>(DataStream&, wallet::CKeyMetadata&)
Line
Count
Source
172
376
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void KeyOriginInfo::Unser<DataStream>(DataStream&, KeyOriginInfo&)
Line
Count
Source
172
277
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void wallet::CMasterKey::Unser<DataStream>(DataStream&, wallet::CMasterKey&)
Line
Count
Source
172
27
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
void wallet::CHDChain::Unser<DataStream>(DataStream&, wallet::CHDChain&)
Line
Count
Source
172
38
    static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \
173
    template<typename Stream, typename Type, typename Operation> \
174
    static void SerializationOps(Type& obj, Stream& s, Operation ser_action)
175
176
/**
177
 * Formatter methods can retrieve parameters attached to a stream using the
178
 * SER_PARAMS(type) macro as long as the stream is created directly or
179
 * indirectly with a parameter of that type. This permits making serialization
180
 * depend on run-time context in a type-safe way.
181
 *
182
 * Example use:
183
 *   struct BarParameter { bool fancy; ... };
184
 *   struct Bar { ... };
185
 *   struct FooFormatter {
186
 *     FORMATTER_METHODS(Bar, obj) {
187
 *       auto& param = SER_PARAMS(BarParameter);
188
 *       if (param.fancy) {
189
 *         READWRITE(VARINT(obj.value));
190
 *       } else {
191
 *         READWRITE(obj.value);
192
 *       }
193
 *     }
194
 *   };
195
 * which would then be invoked as
196
 *   READWRITE(BarParameter{...}(Using<FooFormatter>(obj.foo)))
197
 *
198
 * parameter(obj) can be invoked anywhere in the call stack; it is
199
 * passed down recursively into all serialization code, until another
200
 * serialization parameter overrides it.
201
 *
202
 * Parameters will be implicitly converted where appropriate. This means that
203
 * "parent" serialization code can use a parameter that derives from, or is
204
 * convertible to, a "child" formatter's parameter type.
205
 *
206
 * Compilation will fail in any context where serialization is invoked but
207
 * no parameter of a type convertible to BarParameter is provided.
208
 */
209
96.8k
#define SER_PARAMS(type) (s.template GetParams<type>())
210
211
#define BASE_SERIALIZE_METHODS(cls)                                                                 \
212
    template <typename Stream>                                                                      \
213
    void Serialize(Stream& s) const                                                                 \
214
124M
    {                                                                                               \
215
124M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
124M
        Ser(s, *this);                                                                              \
217
124M
    }                                                                                               \
void CTxIn::Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&) const
Line
Count
Source
214
4.47M
    {                                                                                               \
215
4.47M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
4.47M
        Ser(s, *this);                                                                              \
217
4.47M
    }                                                                                               \
void CScript::Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&) const
Line
Count
Source
214
11.6M
    {                                                                                               \
215
11.6M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
11.6M
        Ser(s, *this);                                                                              \
217
11.6M
    }                                                                                               \
void COutPoint::Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&) const
Line
Count
Source
214
4.47M
    {                                                                                               \
215
4.47M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
4.47M
        Ser(s, *this);                                                                              \
217
4.47M
    }                                                                                               \
void CTxOut::Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&) const
Line
Count
Source
214
7.16M
    {                                                                                               \
215
7.16M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
7.16M
        Ser(s, *this);                                                                              \
217
7.16M
    }                                                                                               \
void CBlock::Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&) const
Line
Count
Source
214
710k
    {                                                                                               \
215
710k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
710k
        Ser(s, *this);                                                                              \
217
710k
    }                                                                                               \
void CBlockHeader::Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&) const
Line
Count
Source
214
710k
    {                                                                                               \
215
710k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
710k
        Ser(s, *this);                                                                              \
217
710k
    }                                                                                               \
void AddrInfo::Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&) const
Line
Count
Source
214
17
    {                                                                                               \
215
17
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
17
        Ser(s, *this);                                                                              \
217
17
    }                                                                                               \
void CAddress::Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&) const
Line
Count
Source
214
23
    {                                                                                               \
215
23
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
23
        Ser(s, *this);                                                                              \
217
23
    }                                                                                               \
void CService::Serialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&) const
Line
Count
Source
214
23
    {                                                                                               \
215
23
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
23
        Ser(s, *this);                                                                              \
217
23
    }                                                                                               \
void CBlockHeaderAndShortTxIDs::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
4
    {                                                                                               \
215
4
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
4
        Ser(s, *this);                                                                              \
217
4
    }                                                                                               \
void CBlockHeader::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
97.0k
    {                                                                                               \
215
97.0k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
97.0k
        Ser(s, *this);                                                                              \
217
97.0k
    }                                                                                               \
void PrefilledTransaction::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
11
    {                                                                                               \
215
11
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
11
        Ser(s, *this);                                                                              \
217
11
    }                                                                                               \
void CTxIn::Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&) const
Line
Count
Source
214
125k
    {                                                                                               \
215
125k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
125k
        Ser(s, *this);                                                                              \
217
125k
    }                                                                                               \
void COutPoint::Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&) const
Line
Count
Source
214
125k
    {                                                                                               \
215
125k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
125k
        Ser(s, *this);                                                                              \
217
125k
    }                                                                                               \
void CScript::Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&) const
Line
Count
Source
214
393k
    {                                                                                               \
215
393k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
393k
        Ser(s, *this);                                                                              \
217
393k
    }                                                                                               \
void CTxOut::Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&) const
Line
Count
Source
214
267k
    {                                                                                               \
215
267k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
267k
        Ser(s, *this);                                                                              \
217
267k
    }                                                                                               \
void blockencodings_tests::TestHeaderAndShortIDs::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
5
    {                                                                                               \
215
5
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
5
        Ser(s, *this);                                                                              \
217
5
    }                                                                                               \
void BlockTransactionsRequest::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
2
    {                                                                                               \
215
2
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
2
        Ser(s, *this);                                                                              \
217
2
    }                                                                                               \
void CBloomFilter::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
3
    {                                                                                               \
215
3
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
3
        Ser(s, *this);                                                                              \
217
3
    }                                                                                               \
void CMerkleBlock::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
14
    {                                                                                               \
215
14
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
14
        Ser(s, *this);                                                                              \
217
14
    }                                                                                               \
void CPartialMerkleTree::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
182
    {                                                                                               \
215
182
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
182
        Ser(s, *this);                                                                              \
217
182
    }                                                                                               \
void MuHash3072::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
120
    {                                                                                               \
215
120
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
120
        Ser(s, *this);                                                                              \
217
120
    }                                                                                               \
void Num3072::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
240
    {                                                                                               \
215
240
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
240
        Ser(s, *this);                                                                              \
217
240
    }                                                                                               \
void CTxIn::Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&) const
Line
Count
Source
214
69.5k
    {                                                                                               \
215
69.5k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
69.5k
        Ser(s, *this);                                                                              \
217
69.5k
    }                                                                                               \
void COutPoint::Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&) const
Line
Count
Source
214
69.5k
    {                                                                                               \
215
69.5k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
69.5k
        Ser(s, *this);                                                                              \
217
69.5k
    }                                                                                               \
void CScript::Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&) const
Line
Count
Source
214
240k
    {                                                                                               \
215
240k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
240k
        Ser(s, *this);                                                                              \
217
240k
    }                                                                                               \
void CTxOut::Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&) const
Line
Count
Source
214
170k
    {                                                                                               \
215
170k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
170k
        Ser(s, *this);                                                                              \
217
170k
    }                                                                                               \
void CTxIn::Serialize<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&) const
Line
Count
Source
214
2.10M
    {                                                                                               \
215
2.10M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
2.10M
        Ser(s, *this);                                                                              \
217
2.10M
    }                                                                                               \
void COutPoint::Serialize<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&) const
Line
Count
Source
214
2.10M
    {                                                                                               \
215
2.10M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
2.10M
        Ser(s, *this);                                                                              \
217
2.10M
    }                                                                                               \
void CScript::Serialize<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&) const
Line
Count
Source
214
5.94M
    {                                                                                               \
215
5.94M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
5.94M
        Ser(s, *this);                                                                              \
217
5.94M
    }                                                                                               \
void CTxOut::Serialize<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&) const
Line
Count
Source
214
3.83M
    {                                                                                               \
215
3.83M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
3.83M
        Ser(s, *this);                                                                              \
217
3.83M
    }                                                                                               \
void CMessageHeader::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
2
    {                                                                                               \
215
2
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
2
        Ser(s, *this);                                                                              \
217
2
    }                                                                                               \
void CService::Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&) const
Line
Count
Source
214
1
    {                                                                                               \
215
1
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
1
        Ser(s, *this);                                                                              \
217
1
    }                                                                                               \
void serialize_tests::CSerializeMethodsTestSingle::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
1
    {                                                                                               \
215
1
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
1
        Ser(s, *this);                                                                              \
217
1
    }                                                                                               \
void serialize_tests::CSerializeMethodsTestMany::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
1
    {                                                                                               \
215
1
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
1
        Ser(s, *this);                                                                              \
217
1
    }                                                                                               \
void serialize_tests::Derived::Serialize<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&) const
Line
Count
Source
214
2
    {                                                                                               \
215
2
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
2
        Ser(s, *this);                                                                              \
217
2
    }                                                                                               \
void txindex::BlockTxPosition::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
4.58k
    {                                                                                               \
215
4.58k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
4.58k
        Ser(s, *this);                                                                              \
217
4.58k
    }                                                                                               \
void txindex::BlockSeqKey::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
4.31k
    {                                                                                               \
215
4.31k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
4.31k
        Ser(s, *this);                                                                              \
217
4.31k
    }                                                                                               \
void txindex::DBKey::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
4.57k
    {                                                                                               \
215
4.57k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
4.57k
        Ser(s, *this);                                                                              \
217
4.57k
    }                                                                                               \
void CBlockHeader::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
214
35.6k
    {                                                                                               \
215
35.6k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
35.6k
        Ser(s, *this);                                                                              \
217
35.6k
    }                                                                                               \
void CDiskTxPos::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
46
    {                                                                                               \
215
46
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
46
        Ser(s, *this);                                                                              \
217
46
    }                                                                                               \
void FlatFilePos::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
8.33k
    {                                                                                               \
215
8.33k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
8.33k
        Ser(s, *this);                                                                              \
217
8.33k
    }                                                                                               \
void CBlockLocator::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
25.7k
    {                                                                                               \
215
25.7k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
25.7k
        Ser(s, *this);                                                                              \
217
25.7k
    }                                                                                               \
void CTxOut::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
214
402k
    {                                                                                               \
215
402k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
402k
        Ser(s, *this);                                                                              \
217
402k
    }                                                                                               \
void CScript::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
214
402k
    {                                                                                               \
215
402k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
402k
        Ser(s, *this);                                                                              \
217
402k
    }                                                                                               \
void CTxOut::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
7.45k
    {                                                                                               \
215
7.45k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
7.45k
        Ser(s, *this);                                                                              \
217
7.45k
    }                                                                                               \
void CScript::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
10.0k
    {                                                                                               \
215
10.0k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
10.0k
        Ser(s, *this);                                                                              \
217
10.0k
    }                                                                                               \
void XOnlyPubKey::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
214
5.96k
    {                                                                                               \
215
5.96k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
5.96k
        Ser(s, *this);                                                                              \
217
5.96k
    }                                                                                               \
void XOnlyPubKey::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
5.96k
    {                                                                                               \
215
5.96k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
5.96k
        Ser(s, *this);                                                                              \
217
5.96k
    }                                                                                               \
void CService::Serialize<ParamsStream<VectorWriter&, CNetAddr::SerParams>>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&) const
Line
Count
Source
214
3.48k
    {                                                                                               \
215
3.48k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
3.48k
        Ser(s, *this);                                                                              \
217
3.48k
    }                                                                                               \
void CAddress::Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&) const
Line
Count
Source
214
50.3k
    {                                                                                               \
215
50.3k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
50.3k
        Ser(s, *this);                                                                              \
217
50.3k
    }                                                                                               \
void CService::Serialize<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&) const
Line
Count
Source
214
50.3k
    {                                                                                               \
215
50.3k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
50.3k
        Ser(s, *this);                                                                              \
217
50.3k
    }                                                                                               \
void AddrInfo::Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&) const
Line
Count
Source
214
50.3k
    {                                                                                               \
215
50.3k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
50.3k
        Ser(s, *this);                                                                              \
217
50.3k
    }                                                                                               \
void CBlockHeaderAndShortTxIDs::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
214
35.6k
    {                                                                                               \
215
35.6k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
35.6k
        Ser(s, *this);                                                                              \
217
35.6k
    }                                                                                               \
void PrefilledTransaction::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
214
35.7k
    {                                                                                               \
215
35.7k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
35.7k
        Ser(s, *this);                                                                              \
217
35.7k
    }                                                                                               \
void index_util::DBHashKey::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
268
    {                                                                                               \
215
268
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
268
        Ser(s, *this);                                                                              \
217
268
    }                                                                                               \
blockfilterindex.cpp:void (anonymous namespace)::DBVal::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
8.11k
    {                                                                                               \
215
8.11k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
8.11k
        Ser(s, *this);                                                                              \
217
8.11k
    }                                                                                               \
coinstatsindex.cpp:void (anonymous namespace)::DBVal::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
4.22k
    {                                                                                               \
215
4.22k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
4.22k
        Ser(s, *this);                                                                              \
217
4.22k
    }                                                                                               \
void txindex::BlockHashKey::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
8.81k
    {                                                                                               \
215
8.81k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
8.81k
        Ser(s, *this);                                                                              \
217
8.81k
    }                                                                                               \
void DBKey::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
44
    {                                                                                               \
215
44
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
44
        Ser(s, *this);                                                                              \
217
44
    }                                                                                               \
void COutPoint::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
214
21.5M
    {                                                                                               \
215
21.5M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
21.5M
        Ser(s, *this);                                                                              \
217
21.5M
    }                                                                                               \
void CTxOut::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
214
14.4M
    {                                                                                               \
215
14.4M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
14.4M
        Ser(s, *this);                                                                              \
217
14.4M
    }                                                                                               \
void CScript::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
214
15.4M
    {                                                                                               \
215
15.4M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
15.4M
        Ser(s, *this);                                                                              \
217
15.4M
    }                                                                                               \
void COutPoint::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
6.20k
    {                                                                                               \
215
6.20k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
6.20k
        Ser(s, *this);                                                                              \
217
6.20k
    }                                                                                               \
void CMessageHeader::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
214
136k
    {                                                                                               \
215
136k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
136k
        Ser(s, *this);                                                                              \
217
136k
    }                                                                                               \
void CBlockHeaderAndShortTxIDs::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
214
18.8k
    {                                                                                               \
215
18.8k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
18.8k
        Ser(s, *this);                                                                              \
217
18.8k
    }                                                                                               \
void CBlockHeader::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
214
18.8k
    {                                                                                               \
215
18.8k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
18.8k
        Ser(s, *this);                                                                              \
217
18.8k
    }                                                                                               \
void PrefilledTransaction::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
214
18.8k
    {                                                                                               \
215
18.8k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
18.8k
        Ser(s, *this);                                                                              \
217
18.8k
    }                                                                                               \
void CInv::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
214
84.8k
    {                                                                                               \
215
84.8k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
84.8k
        Ser(s, *this);                                                                              \
217
84.8k
    }                                                                                               \
void CBlock::Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&) const
Line
Count
Source
214
35.0k
    {                                                                                               \
215
35.0k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
35.0k
        Ser(s, *this);                                                                              \
217
35.0k
    }                                                                                               \
void CBlockHeader::Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&) const
Line
Count
Source
214
35.0k
    {                                                                                               \
215
35.0k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
35.0k
        Ser(s, *this);                                                                              \
217
35.0k
    }                                                                                               \
void CMerkleBlock::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
214
4
    {                                                                                               \
215
4
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
4
        Ser(s, *this);                                                                              \
217
4
    }                                                                                               \
void CPartialMerkleTree::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
214
4
    {                                                                                               \
215
4
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
4
        Ser(s, *this);                                                                              \
217
4
    }                                                                                               \
void CBlockLocator::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
214
3.01k
    {                                                                                               \
215
3.01k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
3.01k
        Ser(s, *this);                                                                              \
217
3.01k
    }                                                                                               \
void BlockTransactions::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
214
590
    {                                                                                               \
215
590
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
590
        Ser(s, *this);                                                                              \
217
590
    }                                                                                               \
void BlockTransactionsRequest::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
214
577
    {                                                                                               \
215
577
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
577
        Ser(s, *this);                                                                              \
217
577
    }                                                                                               \
void CAddress::Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&) const
Line
Count
Source
214
18.9k
    {                                                                                               \
215
18.9k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
18.9k
        Ser(s, *this);                                                                              \
217
18.9k
    }                                                                                               \
void CService::Serialize<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&) const
Line
Count
Source
214
18.9k
    {                                                                                               \
215
18.9k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
18.9k
        Ser(s, *this);                                                                              \
217
18.9k
    }                                                                                               \
void kernel::CBlockFileInfo::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
1.72k
    {                                                                                               \
215
1.72k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
1.72k
        Ser(s, *this);                                                                              \
217
1.72k
    }                                                                                               \
void CDiskBlockIndex::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
117k
    {                                                                                               \
215
117k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
117k
        Ser(s, *this);                                                                              \
217
117k
    }                                                                                               \
void CBlockUndo::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
214
100k
    {                                                                                               \
215
100k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
100k
        Ser(s, *this);                                                                              \
217
100k
    }                                                                                               \
void CTxUndo::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
214
45.0k
    {                                                                                               \
215
45.0k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
45.0k
        Ser(s, *this);                                                                              \
217
45.0k
    }                                                                                               \
void CBlockUndo::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
214
100k
    {                                                                                               \
215
100k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
100k
        Ser(s, *this);                                                                              \
217
100k
    }                                                                                               \
void CTxUndo::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
214
45.0k
    {                                                                                               \
215
45.0k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
45.0k
        Ser(s, *this);                                                                              \
217
45.0k
    }                                                                                               \
void CBlockUndo::Serialize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&) const
Line
Count
Source
214
100k
    {                                                                                               \
215
100k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
100k
        Ser(s, *this);                                                                              \
217
100k
    }                                                                                               \
void CTxUndo::Serialize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&) const
Line
Count
Source
214
45.0k
    {                                                                                               \
215
45.0k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
45.0k
        Ser(s, *this);                                                                              \
217
45.0k
    }                                                                                               \
void CBlock::Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&) const
Line
Count
Source
214
102k
    {                                                                                               \
215
102k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
102k
        Ser(s, *this);                                                                              \
217
102k
    }                                                                                               \
void CBlockHeader::Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&) const
Line
Count
Source
214
102k
    {                                                                                               \
215
102k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
102k
        Ser(s, *this);                                                                              \
217
102k
    }                                                                                               \
void CTxIn::Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&) const
Line
Count
Source
214
185k
    {                                                                                               \
215
185k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
185k
        Ser(s, *this);                                                                              \
217
185k
    }                                                                                               \
void COutPoint::Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&) const
Line
Count
Source
214
185k
    {                                                                                               \
215
185k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
185k
        Ser(s, *this);                                                                              \
217
185k
    }                                                                                               \
void CScript::Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&) const
Line
Count
Source
214
567k
    {                                                                                               \
215
567k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
567k
        Ser(s, *this);                                                                              \
217
567k
    }                                                                                               \
void CTxOut::Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&) const
Line
Count
Source
214
381k
    {                                                                                               \
215
381k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
381k
        Ser(s, *this);                                                                              \
217
381k
    }                                                                                               \
void CTxIn::Serialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&) const
Line
Count
Source
214
2.38k
    {                                                                                               \
215
2.38k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
2.38k
        Ser(s, *this);                                                                              \
217
2.38k
    }                                                                                               \
void COutPoint::Serialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&) const
Line
Count
Source
214
2.38k
    {                                                                                               \
215
2.38k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
2.38k
        Ser(s, *this);                                                                              \
217
2.38k
    }                                                                                               \
void CScript::Serialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&) const
Line
Count
Source
214
4.25k
    {                                                                                               \
215
4.25k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
4.25k
        Ser(s, *this);                                                                              \
217
4.25k
    }                                                                                               \
void CTxOut::Serialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&) const
Line
Count
Source
214
1.87k
    {                                                                                               \
215
1.87k
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
1.87k
        Ser(s, *this);                                                                              \
217
1.87k
    }                                                                                               \
void CCoin::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
2
    {                                                                                               \
215
2
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
2
        Ser(s, *this);                                                                              \
217
2
    }                                                                                               \
void CBlock::Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&) const
Line
Count
Source
214
41
    {                                                                                               \
215
41
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
41
        Ser(s, *this);                                                                              \
217
41
    }                                                                                               \
void CBlockHeader::Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&) const
Line
Count
Source
214
42
    {                                                                                               \
215
42
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
42
        Ser(s, *this);                                                                              \
217
42
    }                                                                                               \
txdb.cpp:void (anonymous namespace)::CoinEntry::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
5.62M
    {                                                                                               \
215
5.62M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
5.62M
        Ser(s, *this);                                                                              \
217
5.62M
    }                                                                                               \
void CBlockHeader::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
214
18.6M
    {                                                                                               \
215
18.6M
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
18.6M
        Ser(s, *this);                                                                              \
217
18.6M
    }                                                                                               \
void wallet::CKeyMetadata::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
60
    {                                                                                               \
215
60
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
60
        Ser(s, *this);                                                                              \
217
60
    }                                                                                               \
Unexecuted instantiation: void KeyOriginInfo::Serialize<DataStream>(DataStream&) const
void wallet::CMasterKey::Serialize<DataStream>(DataStream&) const
Line
Count
Source
214
45
    {                                                                                               \
215
45
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
45
        Ser(s, *this);                                                                              \
217
45
    }                                                                                               \
void COutPoint::Serialize<SpanWriter>(SpanWriter&) const
Line
Count
Source
214
59
    {                                                                                               \
215
59
        static_assert(std::is_same_v<const cls&, decltype(*this)>, "Serialize type mismatch");      \
216
59
        Ser(s, *this);                                                                              \
217
59
    }                                                                                               \
218
    template <typename Stream>                                                                      \
219
    void Unserialize(Stream& s)                                                                     \
220
4.84M
    {                                                                                               \
221
4.84M
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
4.84M
        Unser(s, *this);                                                                            \
223
4.84M
    }
void blockencodings_tests::TestHeaderAndShortIDs::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
2
    {                                                                                               \
221
2
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
2
        Unser(s, *this);                                                                            \
223
2
    }
void CBlockHeader::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
476k
    {                                                                                               \
221
476k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
476k
        Unser(s, *this);                                                                            \
223
476k
    }
void PrefilledTransaction::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
21.6k
    {                                                                                               \
221
21.6k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
21.6k
        Unser(s, *this);                                                                            \
223
21.6k
    }
void CTxIn::Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
220
137k
    {                                                                                               \
221
137k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
137k
        Unser(s, *this);                                                                            \
223
137k
    }
void COutPoint::Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
220
137k
    {                                                                                               \
221
137k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
137k
        Unser(s, *this);                                                                            \
223
137k
    }
void CScript::Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
220
426k
    {                                                                                               \
221
426k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
426k
        Unser(s, *this);                                                                            \
223
426k
    }
void CTxOut::Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
220
289k
    {                                                                                               \
221
289k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
289k
        Unser(s, *this);                                                                            \
223
289k
    }
void CBlockHeaderAndShortTxIDs::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
21.6k
    {                                                                                               \
221
21.6k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
21.6k
        Unser(s, *this);                                                                            \
223
21.6k
    }
void BlockTransactionsRequest::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
597
    {                                                                                               \
221
597
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
597
        Unser(s, *this);                                                                            \
223
597
    }
void CTxIn::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
4.79k
    {                                                                                               \
221
4.79k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
4.79k
        Unser(s, *this);                                                                            \
223
4.79k
    }
void COutPoint::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
4.79k
    {                                                                                               \
221
4.79k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
4.79k
        Unser(s, *this);                                                                            \
223
4.79k
    }
void CScript::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
9.76k
    {                                                                                               \
221
9.76k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
9.76k
        Unser(s, *this);                                                                            \
223
9.76k
    }
void CTxOut::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
4.78k
    {                                                                                               \
221
4.78k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
4.78k
        Unser(s, *this);                                                                            \
223
4.78k
    }
void CTxIn::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
1
    {                                                                                               \
221
1
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
1
        Unser(s, *this);                                                                            \
223
1
    }
void COutPoint::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
1
    {                                                                                               \
221
1
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
1
        Unser(s, *this);                                                                            \
223
1
    }
void CScript::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
8.14k
    {                                                                                               \
221
8.14k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
8.14k
        Unser(s, *this);                                                                            \
223
8.14k
    }
void CTxOut::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
4.78k
    {                                                                                               \
221
4.78k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
4.78k
        Unser(s, *this);                                                                            \
223
4.78k
    }
void CBlock::Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
220
34.2k
    {                                                                                               \
221
34.2k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
34.2k
        Unser(s, *this);                                                                            \
223
34.2k
    }
void CBlockHeader::Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
220
34.2k
    {                                                                                               \
221
34.2k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
34.2k
        Unser(s, *this);                                                                            \
223
34.2k
    }
void MuHash3072::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
2
    {                                                                                               \
221
2
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
2
        Unser(s, *this);                                                                            \
223
2
    }
void Num3072::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
4
    {                                                                                               \
221
4
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
4
        Unser(s, *this);                                                                            \
223
4
    }
void CAddress::Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&)
Line
Count
Source
220
7
    {                                                                                               \
221
7
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
7
        Unser(s, *this);                                                                            \
223
7
    }
void CService::Unserialize<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
220
7
    {                                                                                               \
221
7
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
7
        Unser(s, *this);                                                                            \
223
7
    }
void CPartialMerkleTree::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
168
    {                                                                                               \
221
168
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
168
        Unser(s, *this);                                                                            \
223
168
    }
void CTxIn::Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
220
332k
    {                                                                                               \
221
332k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
332k
        Unser(s, *this);                                                                            \
223
332k
    }
void COutPoint::Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
220
332k
    {                                                                                               \
221
332k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
332k
        Unser(s, *this);                                                                            \
223
332k
    }
void CScript::Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
220
853k
    {                                                                                               \
221
853k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
853k
        Unser(s, *this);                                                                            \
223
853k
    }
void CTxOut::Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
220
521k
    {                                                                                               \
221
521k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
521k
        Unser(s, *this);                                                                            \
223
521k
    }
void serialize_tests::CSerializeMethodsTestMany::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
1
    {                                                                                               \
221
1
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
1
        Unser(s, *this);                                                                            \
223
1
    }
void serialize_tests::CSerializeMethodsTestSingle::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
2
    {                                                                                               \
221
2
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
2
        Unser(s, *this);                                                                            \
223
2
    }
void txindex::DBKey::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
326
    {                                                                                               \
221
326
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
326
        Unser(s, *this);                                                                            \
223
326
    }
void txindex::BlockTxPosition::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
326
    {                                                                                               \
221
326
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
326
        Unser(s, *this);                                                                            \
223
326
    }
void txindex::BlockTxPosition::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
4
    {                                                                                               \
221
4
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
4
        Unser(s, *this);                                                                            \
223
4
    }
void CBlockLocator::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
110
    {                                                                                               \
221
110
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
110
        Unser(s, *this);                                                                            \
223
110
    }
void XOnlyPubKey::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
8.15k
    {                                                                                               \
221
8.15k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
8.15k
        Unser(s, *this);                                                                            \
223
8.15k
    }
Unexecuted instantiation: void XOnlyPubKey::Unserialize<DataStream>(DataStream&)
void CAddress::Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
Line
Count
Source
220
20.5k
    {                                                                                               \
221
20.5k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
20.5k
        Unser(s, *this);                                                                            \
223
20.5k
    }
void CService::Unserialize<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
220
20.5k
    {                                                                                               \
221
20.5k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
20.5k
        Unser(s, *this);                                                                            \
223
20.5k
    }
Unexecuted instantiation: void AddrInfo::Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&)
Unexecuted instantiation: void CAddress::Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&)
Unexecuted instantiation: void CService::Unserialize<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&)
void AddrInfo::Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
Line
Count
Source
220
20.5k
    {                                                                                               \
221
20.5k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
20.5k
        Unser(s, *this);                                                                            \
223
20.5k
    }
void AddrInfo::Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
220
14
    {                                                                                               \
221
14
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
14
        Unser(s, *this);                                                                            \
223
14
    }
void CAddress::Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
220
6.92k
    {                                                                                               \
221
6.92k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
6.92k
        Unser(s, *this);                                                                            \
223
6.92k
    }
void CService::Unserialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
220
6.91k
    {                                                                                               \
221
6.91k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
6.91k
        Unser(s, *this);                                                                            \
223
6.91k
    }
void AddrInfo::Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&)
Line
Count
Source
220
5
    {                                                                                               \
221
5
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
5
        Unser(s, *this);                                                                            \
223
5
    }
void CAddress::Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&)
Line
Count
Source
220
5
    {                                                                                               \
221
5
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
5
        Unser(s, *this);                                                                            \
223
5
    }
void CService::Unserialize<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
220
4
    {                                                                                               \
221
4
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
4
        Unser(s, *this);                                                                            \
223
4
    }
blockfilterindex.cpp:void (anonymous namespace)::DBVal::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
2.97k
    {                                                                                               \
221
2.97k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
2.97k
        Unser(s, *this);                                                                            \
223
2.97k
    }
void FlatFilePos::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
2.97k
    {                                                                                               \
221
2.97k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
2.97k
        Unser(s, *this);                                                                            \
223
2.97k
    }
blockfilterindex.cpp:void (anonymous namespace)::DBVal::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
1.06k
    {                                                                                               \
221
1.06k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
1.06k
        Unser(s, *this);                                                                            \
223
1.06k
    }
void FlatFilePos::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
1.12k
    {                                                                                               \
221
1.12k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
1.12k
        Unser(s, *this);                                                                            \
223
1.12k
    }
coinstatsindex.cpp:void (anonymous namespace)::DBVal::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
121
    {                                                                                               \
221
121
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
121
        Unser(s, *this);                                                                            \
223
121
    }
coinstatsindex.cpp:void (anonymous namespace)::DBVal::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
224
    {                                                                                               \
221
224
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
224
        Unser(s, *this);                                                                            \
223
224
    }
void MuHash3072::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
32
    {                                                                                               \
221
32
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
32
        Unser(s, *this);                                                                            \
223
32
    }
void Num3072::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
64
    {                                                                                               \
221
64
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
64
        Unser(s, *this);                                                                            \
223
64
    }
void CTxIn::Unserialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&)
Line
Count
Source
220
517
    {                                                                                               \
221
517
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
517
        Unser(s, *this);                                                                            \
223
517
    }
void COutPoint::Unserialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&)
Line
Count
Source
220
517
    {                                                                                               \
221
517
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
517
        Unser(s, *this);                                                                            \
223
517
    }
void CScript::Unserialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&)
Line
Count
Source
220
1.34k
    {                                                                                               \
221
1.34k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
1.34k
        Unser(s, *this);                                                                            \
223
1.34k
    }
void CTxOut::Unserialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&)
Line
Count
Source
220
832
    {                                                                                               \
221
832
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
832
        Unser(s, *this);                                                                            \
223
832
    }
void CDiskTxPos::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
29
    {                                                                                               \
221
29
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
29
        Unser(s, *this);                                                                            \
223
29
    }
void CBlockHeader::Unserialize<AutoFile>(AutoFile&)
Line
Count
Source
220
24
    {                                                                                               \
221
24
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
24
        Unser(s, *this);                                                                            \
223
24
    }
void DBKey::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
26
    {                                                                                               \
221
26
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
26
        Unser(s, *this);                                                                            \
223
26
    }
Unexecuted instantiation: void CService::Unserialize<ParamsStream<SpanReader, CAddress::SerParams>>(ParamsStream<SpanReader, CAddress::SerParams>&)
void CMessageHeader::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
129k
    {                                                                                               \
221
129k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
129k
        Unser(s, *this);                                                                            \
223
129k
    }
void CService::Unserialize<ParamsStream<DataStream&, CNetAddr::SerParams>>(ParamsStream<DataStream&, CNetAddr::SerParams>&)
Line
Count
Source
220
1.73k
    {                                                                                               \
221
1.73k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
1.73k
        Unser(s, *this);                                                                            \
223
1.73k
    }
void CInv::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
167k
    {                                                                                               \
221
167k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
167k
        Unser(s, *this);                                                                            \
223
167k
    }
void CBlockLocator::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
5.20k
    {                                                                                               \
221
5.20k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
5.20k
        Unser(s, *this);                                                                            \
223
5.20k
    }
void BlockTransactions::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
572
    {                                                                                               \
221
572
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
572
        Unser(s, *this);                                                                            \
223
572
    }
void CBloomFilter::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
10
    {                                                                                               \
221
10
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
10
        Unser(s, *this);                                                                            \
223
10
    }
void kernel::CBlockFileInfo::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
839
    {                                                                                               \
221
839
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
839
        Unser(s, *this);                                                                            \
223
839
    }
void CDiskBlockIndex::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
152k
    {                                                                                               \
221
152k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
152k
        Unser(s, *this);                                                                            \
223
152k
    }
void CBlockUndo::Unserialize<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
220
33.7k
    {                                                                                               \
221
33.7k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
33.7k
        Unser(s, *this);                                                                            \
223
33.7k
    }
void CTxUndo::Unserialize<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
220
21.0k
    {                                                                                               \
221
21.0k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
21.0k
        Unser(s, *this);                                                                            \
223
21.0k
    }
void CBlock::Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
220
140k
    {                                                                                               \
221
140k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
140k
        Unser(s, *this);                                                                            \
223
140k
    }
void CBlockHeader::Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
220
140k
    {                                                                                               \
221
140k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
140k
        Unser(s, *this);                                                                            \
223
140k
    }
void CMerkleBlock::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
20
    {                                                                                               \
221
20
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
20
        Unser(s, *this);                                                                            \
223
20
    }
void CBlockHeader::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
1.86k
    {                                                                                               \
221
1.86k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
1.86k
        Unser(s, *this);                                                                            \
223
1.86k
    }
void CPartialMerkleTree::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
20
    {                                                                                               \
221
20
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
20
        Unser(s, *this);                                                                            \
223
20
    }
txdb.cpp:void (anonymous namespace)::CoinEntry::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
220
279k
    {                                                                                               \
221
279k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
279k
        Unser(s, *this);                                                                            \
223
279k
    }
void CBlockHeader::Unserialize<BufferedFile>(BufferedFile&)
Line
Count
Source
220
2.02k
    {                                                                                               \
221
2.02k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
2.02k
        Unser(s, *this);                                                                            \
223
2.02k
    }
void CBlock::Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
220
1.91k
    {                                                                                               \
221
1.91k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
1.91k
        Unser(s, *this);                                                                            \
223
1.91k
    }
void CBlockHeader::Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
220
1.91k
    {                                                                                               \
221
1.91k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
1.91k
        Unser(s, *this);                                                                            \
223
1.91k
    }
void CTxIn::Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
220
2.01k
    {                                                                                               \
221
2.01k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
2.01k
        Unser(s, *this);                                                                            \
223
2.01k
    }
void COutPoint::Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
220
2.01k
    {                                                                                               \
221
2.01k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
2.01k
        Unser(s, *this);                                                                            \
223
2.01k
    }
void CScript::Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
220
5.97k
    {                                                                                               \
221
5.97k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
5.97k
        Unser(s, *this);                                                                            \
223
5.97k
    }
void CTxOut::Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
220
3.96k
    {                                                                                               \
221
3.96k
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
3.96k
        Unser(s, *this);                                                                            \
223
3.96k
    }
void wallet::CKeyMetadata::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
376
    {                                                                                               \
221
376
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
376
        Unser(s, *this);                                                                            \
223
376
    }
void KeyOriginInfo::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
277
    {                                                                                               \
221
277
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
277
        Unser(s, *this);                                                                            \
223
277
    }
void wallet::CMasterKey::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
27
    {                                                                                               \
221
27
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
27
        Unser(s, *this);                                                                            \
223
27
    }
void wallet::CHDChain::Unserialize<DataStream>(DataStream&)
Line
Count
Source
220
38
    {                                                                                               \
221
38
        static_assert(std::is_same_v<cls&, decltype(*this)>, "Unserialize type mismatch");          \
222
38
        Unser(s, *this);                                                                            \
223
38
    }
224
225
/**
226
 * Implement the Serialize and Unserialize methods by delegating to a single templated
227
 * static method that takes the to-be-(de)serialized object as a parameter. This approach
228
 * has the advantage that the constness of the object becomes a template parameter, and
229
 * thus allows a single implementation that sees the object as const for serializing
230
 * and non-const for deserializing, without casts.
231
 */
232
#define SERIALIZE_METHODS(cls, obj) \
233
    BASE_SERIALIZE_METHODS(cls)     \
234
    FORMATTER_METHODS(cls, obj)
235
236
// Templates for serializing to anything that looks like a stream,
237
// i.e. anything that supports .read(std::span<std::byte>) and .write(std::span<const std::byte>)
238
//
239
240
// Typically int8_t and char are distinct types, but some systems may define int8_t
241
// in terms of char. Forbid serialization of char in the typical case, but allow it if
242
// it's the only way to describe an int8_t.
243
template<class T>
244
concept CharNotInt8 = std::same_as<T, char> && !std::same_as<T, int8_t>;
245
246
// clang-format off
247
template <typename Stream, CharNotInt8 V> void Serialize(Stream&, V) = delete; // char serialization forbidden. Use uint8_t or int8_t
248
2
template <typename Stream> void Serialize(Stream& s, std::byte a) { ser_writedata8(s, uint8_t(a)); }
void Serialize<DataStream>(DataStream&, std::byte)
Line
Count
Source
248
1
template <typename Stream> void Serialize(Stream& s, std::byte a) { ser_writedata8(s, uint8_t(a)); }
void Serialize<AutoFile>(AutoFile&, std::byte)
Line
Count
Source
248
1
template <typename Stream> void Serialize(Stream& s, std::byte a) { ser_writedata8(s, uint8_t(a)); }
249
2
template <typename Stream> void Serialize(Stream& s, int8_t a)    { ser_writedata8(s, uint8_t(a)); }
250
9.11M
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, unsigned char)
Line
Count
Source
250
734k
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<DataStream>(DataStream&, unsigned char)
Line
Count
Source
250
5.83M
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char)
Line
Count
Source
250
18
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned char)
Line
Count
Source
250
34
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, unsigned char)
Line
Count
Source
250
95.2k
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<VectorWriter>(VectorWriter&, unsigned char)
Line
Count
Source
250
186k
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, unsigned char)
Line
Count
Source
250
32.9k
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&, unsigned char)
Line
Count
Source
250
404k
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
Unexecuted instantiation: void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned char)
void Serialize<SizeComputer>(SizeComputer&, unsigned char)
Line
Count
Source
250
78.9k
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>>(ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, unsigned char)
Line
Count
Source
250
2
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>>(ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>&, unsigned char)
Line
Count
Source
250
1
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>>(ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>&, unsigned char)
Line
Count
Source
250
1
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, unsigned char)
Line
Count
Source
250
3
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>>(ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>&, unsigned char)
Line
Count
Source
250
1
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<SpanWriter>(SpanWriter&, unsigned char)
Line
Count
Source
250
8
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<AutoFile>(AutoFile&, unsigned char)
Line
Count
Source
250
6.51k
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
Unexecuted instantiation: void Serialize<ParamsStream<VectorWriter&, CNetAddr::SerParams>>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, unsigned char)
void Serialize<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char)
Line
Count
Source
250
50.3k
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<HashWriter>(HashWriter&, unsigned char)
Line
Count
Source
250
1.45M
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, unsigned char)
Line
Count
Source
250
53.5k
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char)
Line
Count
Source
250
33
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&, unsigned char)
Line
Count
Source
250
69.5k
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, unsigned char)
Line
Count
Source
250
117k
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, unsigned char)
Line
Count
Source
250
1.14k
template <typename Stream> void Serialize(Stream& s, uint8_t a)   { ser_writedata8(s, a); }
251
2
template <typename Stream> void Serialize(Stream& s, int16_t a)   { ser_writedata16(s, uint16_t(a)); }
252
47
template <typename Stream> void Serialize(Stream& s, uint16_t a)  { ser_writedata16(s, a); }
void Serialize<SizeComputer>(SizeComputer&, unsigned short)
Line
Count
Source
252
2
template <typename Stream> void Serialize(Stream& s, uint16_t a)  { ser_writedata16(s, a); }
void Serialize<DataStream>(DataStream&, unsigned short)
Line
Count
Source
252
1
template <typename Stream> void Serialize(Stream& s, uint16_t a)  { ser_writedata16(s, a); }
void Serialize<AutoFile>(AutoFile&, unsigned short)
Line
Count
Source
252
44
template <typename Stream> void Serialize(Stream& s, uint16_t a)  { ser_writedata16(s, a); }
253
26.4M
template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, int)
Line
Count
Source
253
710k
template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
void Serialize<DataStream>(DataStream&, int)
Line
Count
Source
253
4.66M
template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, int)
Line
Count
Source
253
7.21k
template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
void Serialize<HashWriter>(HashWriter&, int)
Line
Count
Source
253
19.1M
template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
void Serialize<VectorWriter>(VectorWriter&, int)
Line
Count
Source
253
25.3k
template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
void Serialize<SizeComputer>(SizeComputer&, int)
Line
Count
Source
253
35.7k
template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, int)
Line
Count
Source
253
1.77M
template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, int)
Line
Count
Source
253
35.0k
template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, int)
Line
Count
Source
253
102k
template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
void Serialize<AutoFile>(AutoFile&, int)
Line
Count
Source
253
2.23k
template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
void Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, int)
Line
Count
Source
253
42
template <typename Stream> void Serialize(Stream& s, int32_t a)   { ser_writedata32(s, uint32_t(a)); }
254
114M
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, unsigned int)
Line
Count
Source
254
18.4M
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned int)
Line
Count
Source
254
40
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<DataStream>(DataStream&, unsigned int)
Line
Count
Source
254
782k
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, unsigned int)
Line
Count
Source
254
453k
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, unsigned int)
Line
Count
Source
254
362k
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&, unsigned int)
Line
Count
Source
254
9.04M
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<SizeComputer>(SizeComputer&, unsigned int)
Line
Count
Source
254
113k
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&, unsigned int)
Line
Count
Source
254
203k
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<VectorWriter>(VectorWriter&, unsigned int)
Line
Count
Source
254
290k
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, unsigned int)
Line
Count
Source
254
100k
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<HashWriter>(HashWriter&, unsigned int)
Line
Count
Source
254
83.2M
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned int)
Line
Count
Source
254
18.9k
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, unsigned int)
Line
Count
Source
254
987k
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, unsigned int)
Line
Count
Source
254
7.19k
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<AutoFile>(AutoFile&, unsigned int)
Line
Count
Source
254
6.69k
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
void Serialize<SpanWriter>(SpanWriter&, unsigned int)
Line
Count
Source
254
59
template <typename Stream> void Serialize(Stream& s, uint32_t a)  { ser_writedata32(s, a); }
255
26.9M
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, long)
Line
Count
Source
255
7.16M
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, long)
Line
Count
Source
255
17
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, long)
Line
Count
Source
255
267k
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, long)
Line
Count
Source
255
170k
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&, long)
Line
Count
Source
255
3.83M
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<VectorWriter>(VectorWriter&, long)
Line
Count
Source
255
3.55k
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<SizeComputer>(SizeComputer&, long)
Line
Count
Source
255
404k
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<DataStream>(DataStream&, long)
Line
Count
Source
255
53.4k
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, long)
Line
Count
Source
255
50.3k
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<HashWriter>(HashWriter&, long)
Line
Count
Source
255
14.6M
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, long)
Line
Count
Source
255
381k
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, long)
Line
Count
Source
255
1.87k
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
void Serialize<AutoFile>(AutoFile&, long)
Line
Count
Source
255
2.67k
template <typename Stream> void Serialize(Stream& s, int64_t a)   { ser_writedata64(s, uint64_t(a)); }
256
43.4M
template <typename Stream> void Serialize(Stream& s, uint64_t a)  { ser_writedata64(s, a); }
void Serialize<DataStream>(DataStream&, unsigned long)
Line
Count
Source
256
227k
template <typename Stream> void Serialize(Stream& s, uint64_t a)  { ser_writedata64(s, a); }
void Serialize<VectorWriter>(VectorWriter&, unsigned long)
Line
Count
Source
256
38.5k
template <typename Stream> void Serialize(Stream& s, uint64_t a)  { ser_writedata64(s, a); }
void Serialize<SizeComputer>(SizeComputer&, unsigned long)
Line
Count
Source
256
35.6k
template <typename Stream> void Serialize(Stream& s, uint64_t a)  { ser_writedata64(s, a); }
void Serialize<HashWriter>(HashWriter&, unsigned long)
Line
Count
Source
256
47.0k
template <typename Stream> void Serialize(Stream& s, uint64_t a)  { ser_writedata64(s, a); }
void Serialize<AutoFile>(AutoFile&, unsigned long)
Line
Count
Source
256
43.0M
template <typename Stream> void Serialize(Stream& s, uint64_t a)  { ser_writedata64(s, a); }
257
258
301k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char, 16ul>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char const (&) [16ul])
Line
Count
Source
258
5
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, unsigned char, 16ul>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned char const (&) [16ul])
Line
Count
Source
258
8
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, char, 12ul>(DataStream&, char const (&) [12ul])
Line
Count
Source
258
39
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, unsigned char, 4ul>(DataStream&, unsigned char const (&) [4ul])
Line
Count
Source
258
6
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, unsigned char, 16ul>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned char const (&) [16ul])
Line
Count
Source
258
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, char, 16ul>(DataStream&, char const (&) [16ul])
Line
Count
Source
258
2
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, unsigned char, 16ul>(DataStream&, unsigned char const (&) [16ul])
Line
Count
Source
258
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<VectorWriter, unsigned char, 4ul>(VectorWriter&, unsigned char const (&) [4ul])
Line
Count
Source
258
136k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<SpanWriter, unsigned char, 4ul>(SpanWriter&, unsigned char const (&) [4ul])
Line
Count
Source
258
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, unsigned char, 5ul>(DataStream&, unsigned char const (&) [5ul])
Line
Count
Source
258
1.14k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<SizeComputer, unsigned char, 4ul>(SizeComputer&, unsigned char const (&) [4ul])
Line
Count
Source
258
4
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<ParamsStream<VectorWriter&, CNetAddr::SerParams>, unsigned char, 16ul>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, unsigned char const (&) [16ul])
Line
Count
Source
258
3.48k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
Unexecuted instantiation: void Serialize<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char, 16ul>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char const (&) [16ul])
Unexecuted instantiation: void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, unsigned char, 16ul>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, unsigned char const (&) [16ul])
void Serialize<VectorWriter, char, 12ul>(VectorWriter&, char const (&) [12ul])
Line
Count
Source
258
136k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char, 16ul>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char const (&) [16ul])
Line
Count
Source
258
18.9k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
void Serialize<HashWriter, unsigned char, 384ul>(HashWriter&, unsigned char const (&) [384ul])
Line
Count
Source
258
4.34k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const B (&a)[N])           { s.write(MakeByteSpan(a)); }
259
510k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, unsigned char, 4ul>(DataStream&, std::array<unsigned char, 4ul> const&)
Line
Count
Source
259
900
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, std::byte, 6ul>(DataStream&, std::array<std::byte, 6ul> const&)
Line
Count
Source
259
3
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, std::byte, 4ul>(DataStream&, std::array<std::byte, 4ul> const&)
Line
Count
Source
259
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, std::byte, 8ul>(DataStream&, std::array<std::byte, 8ul> const&)
Line
Count
Source
259
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, std::byte, 18ul>(DataStream&, std::array<std::byte, 18ul> const&)
Line
Count
Source
259
6
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, std::byte, 3ul>(DataStream&, std::array<std::byte, 3ul> const&)
Line
Count
Source
259
4
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, std::byte, 12ul>(DataStream&, std::array<std::byte, 12ul> const&)
Line
Count
Source
259
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, std::byte, 34ul>(DataStream&, std::array<std::byte, 34ul> const&)
Line
Count
Source
259
2
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, std::byte, 13ul>(DataStream&, std::array<std::byte, 13ul> const&)
Line
Count
Source
259
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, std::byte, 2ul>(DataStream&, std::array<std::byte, 2ul> const&)
Line
Count
Source
259
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<SizeComputer, unsigned char, 1ul>(SizeComputer&, std::array<unsigned char, 1ul> const&)
Line
Count
Source
259
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<SizeComputer, unsigned char, 2ul>(SizeComputer&, std::array<unsigned char, 2ul> const&)
Line
Count
Source
259
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, unsigned char, 32ul>(DataStream&, std::array<unsigned char, 32ul> const&)
Line
Count
Source
259
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<DataStream, std::byte, 0ul>(DataStream&, std::array<std::byte, 0ul> const&)
Line
Count
Source
259
4.31k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<SizeComputer, unsigned char, 4ul>(SizeComputer&, std::array<unsigned char, 4ul> const&)
Line
Count
Source
259
4
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<VectorWriter, unsigned char, 4ul>(VectorWriter&, std::array<unsigned char, 4ul> const&)
Line
Count
Source
259
299k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<HashedSourceWriter<AutoFile>, unsigned char, 4ul>(HashedSourceWriter<AutoFile>&, std::array<unsigned char, 4ul> const&)
Line
Count
Source
259
1.66k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<VectorWriter, std::byte, 168ul>(VectorWriter&, std::array<std::byte, 168ul> const&)
Line
Count
Source
259
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<AutoFile, std::byte, 8ul>(AutoFile&, std::array<std::byte, 8ul> const&)
Line
Count
Source
259
501
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<BufferedWriter<AutoFile>, unsigned char, 4ul>(BufferedWriter<AutoFile>&, std::array<unsigned char, 4ul> const&)
Line
Count
Source
259
203k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<AutoFile, unsigned char, 5ul>(AutoFile&, std::array<unsigned char, 5ul> const&)
Line
Count
Source
259
44
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
void Serialize<AutoFile, unsigned char, 4ul>(AutoFile&, std::array<unsigned char, 4ul> const&)
Line
Count
Source
259
44
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, const std::array<B, N>& a) { s.write(MakeByteSpan(a)); }
260
76.6M
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, unsigned char const, 32ul>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
5.89M
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<DataStream, unsigned char const, 32ul>(DataStream&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
6.79M
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, unsigned char const, 32ul>(ParamsStream<DataStream&, TransactionSerParams>&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
125k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, unsigned char const, 32ul>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
139k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, unsigned char const, 32ul>(ParamsStream<HashWriter&, TransactionSerParams>&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
2.10M
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<SizeComputer, unsigned char const, 32ul>(SizeComputer&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
88.7k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<HashWriter, unsigned char const, 32ul>(HashWriter&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
60.6M
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<SizeComputer, unsigned char const, 20ul>(SizeComputer&, std::span<unsigned char const, 20ul>)
Line
Count
Source
260
2
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<DataStream, unsigned char const, 20ul>(DataStream&, std::span<unsigned char const, 20ul>)
Line
Count
Source
260
63
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<VectorWriter, unsigned char const, 32ul>(VectorWriter&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
331k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<AutoFile, unsigned char const, 32ul>(AutoFile&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
18.2k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, unsigned char const, 32ul>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
3.25k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, unsigned char const, 32ul>(ParamsStream<DataStream&, CAddress::SerParams>&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
14
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<BufferedWriter<AutoFile>, unsigned char const, 32ul>(BufferedWriter<AutoFile>&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
100k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, unsigned char const, 32ul>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
391k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, unsigned char const, 32ul>(ParamsStream<AutoFile&, TransactionSerParams>&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
2.38k
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<AutoFile, std::byte const, 1582208ul>(AutoFile&, std::span<std::byte const, 1582208ul>)
Line
Count
Source
260
1
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
void Serialize<SpanWriter, unsigned char const, 32ul>(SpanWriter&, std::span<unsigned char const, 32ul>)
Line
Count
Source
260
59
template <typename Stream, BasicByte B, size_t N> void Serialize(Stream& s, std::span<B, N> span)      { s.write(std::as_bytes(span)); }
261
1.64M
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<DataStream, std::byte const>(DataStream&, std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
261
3.96k
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<DataStream, unsigned char const>(DataStream&, std::span<unsigned char const, 18446744073709551615ul>)
Line
Count
Source
261
206k
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<HashWriter, unsigned char const>(HashWriter&, std::span<unsigned char const, 18446744073709551615ul>)
Line
Count
Source
261
1.00M
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<DataStream, char const>(DataStream&, std::span<char const, 18446744073709551615ul>)
Line
Count
Source
261
8
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
Unexecuted instantiation: void Serialize<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>, char const>(ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, std::span<char const, 18446744073709551615ul>)
Unexecuted instantiation: void Serialize<ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, char const>(ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>&, std::span<char const, 18446744073709551615ul>)
void Serialize<ParamsStream<DataStream&, serialize_tests::BaseFormat>, char const>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, std::span<char const, 18446744073709551615ul>)
Line
Count
Source
261
3
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>, char const>(ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>&, std::span<char const, 18446744073709551615ul>)
Line
Count
Source
261
1
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<SizeComputer, unsigned char const>(SizeComputer&, std::span<unsigned char const, 18446744073709551615ul>)
Line
Count
Source
261
66.0k
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<VectorWriter, unsigned char const>(VectorWriter&, std::span<unsigned char const, 18446744073709551615ul>)
Line
Count
Source
261
158k
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<AutoFile, char const>(AutoFile&, std::span<char const, 18446744073709551615ul>)
Line
Count
Source
261
23
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<AutoFile, unsigned char const>(AutoFile&, std::span<unsigned char const, 18446744073709551615ul>)
Line
Count
Source
261
495
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<VectorWriter, std::byte const>(VectorWriter&, std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
261
13.6k
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<SizeComputer, unsigned char>(SizeComputer&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
261
9.16k
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<HashWriter, unsigned char>(HashWriter&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
261
9.16k
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<BufferedWriter<AutoFile>, unsigned char>(BufferedWriter<AutoFile>&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
261
9.16k
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<BufferedWriter<AutoFile>, unsigned char const>(BufferedWriter<AutoFile>&, std::span<unsigned char const, 18446744073709551615ul>)
Line
Count
Source
261
60.4k
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<AutoFile, unsigned char>(AutoFile&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
261
6.11k
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<DataStream, unsigned char>(DataStream&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
261
95.5k
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
void Serialize<HashWriter, std::byte const>(HashWriter&, std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
261
12
template <typename Stream, BasicByte B>           void Serialize(Stream& s, std::span<B> span)         { s.write(std::as_bytes(span)); }
262
263
template <typename Stream, CharNotInt8 V> void Unserialize(Stream&, V) = delete; // char serialization forbidden. Use uint8_t or int8_t
264
31
template <typename Stream> void Unserialize(Stream& s, std::byte& a) { a = std::byte(ser_readdata8(s)); }
void Unserialize<DataStream>(DataStream&, std::byte&)
Line
Count
Source
264
1
template <typename Stream> void Unserialize(Stream& s, std::byte& a) { a = std::byte(ser_readdata8(s)); }
void Unserialize<AutoFile>(AutoFile&, std::byte&)
Line
Count
Source
264
30
template <typename Stream> void Unserialize(Stream& s, std::byte& a) { a = std::byte(ser_readdata8(s)); }
265
1
template <typename Stream> void Unserialize(Stream& s, int8_t& a)    { a = int8_t(ser_readdata8(s)); }
266
830k
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<DataStream>(DataStream&, unsigned char&)
Line
Count
Source
266
10.9k
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, unsigned char&)
Line
Count
Source
266
79.8k
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<SpanReader>(SpanReader&, unsigned char&)
Line
Count
Source
266
478k
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned char&)
Line
Count
Source
266
39
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char&)
Line
Count
Source
266
3
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&, unsigned char&)
Line
Count
Source
266
209k
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>>(ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, unsigned char&)
Line
Count
Source
266
2
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>>(ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>&, unsigned char&)
Line
Count
Source
266
1
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>>(ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>&, unsigned char&)
Line
Count
Source
266
1
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, unsigned char&)
Line
Count
Source
266
3
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<BufferedFile>(BufferedFile&, unsigned char&)
Line
Count
Source
266
671
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<AutoFile>(AutoFile&, unsigned char&)
Line
Count
Source
266
5.23k
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char&)
Line
Count
Source
266
20.5k
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&, unsigned char&)
Unexecuted instantiation: void Unserialize<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char&)
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, unsigned char&)
Line
Count
Source
266
21.1k
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char&)
Line
Count
Source
266
1.03k
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, unsigned char&)
Line
Count
Source
266
5
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char&)
Line
Count
Source
266
3
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, unsigned char&)
Line
Count
Source
266
472
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
Unexecuted instantiation: void Unserialize<ParamsStream<SpanReader, CAddress::SerParams>>(ParamsStream<SpanReader, CAddress::SerParams>&, unsigned char&)
Unexecuted instantiation: void Unserialize<ParamsStream<DataStream&, CNetAddr::SerParams>>(ParamsStream<DataStream&, CNetAddr::SerParams>&, unsigned char&)
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&, unsigned char&)
Line
Count
Source
266
1.97k
template <typename Stream> void Unserialize(Stream& s, uint8_t& a)   { a = ser_readdata8(s); }
267
template <typename Stream> void Unserialize(Stream& s, int16_t& a)   { a = int16_t(ser_readdata16(s)); }
268
9.02k
template <typename Stream> void Unserialize(Stream& s, uint16_t& a)  { a = ser_readdata16(s); }
void Unserialize<SpanReader>(SpanReader&, unsigned short&)
Line
Count
Source
268
2
template <typename Stream> void Unserialize(Stream& s, uint16_t& a)  { a = ser_readdata16(s); }
void Unserialize<DataStream>(DataStream&, unsigned short&)
Line
Count
Source
268
1
template <typename Stream> void Unserialize(Stream& s, uint16_t& a)  { a = ser_readdata16(s); }
void Unserialize<AutoFile>(AutoFile&, unsigned short&)
Line
Count
Source
268
9.02k
template <typename Stream> void Unserialize(Stream& s, uint16_t& a)  { a = ser_readdata16(s); }
269
1.53M
template <typename Stream> void Unserialize(Stream& s, int32_t& a)   { a = int32_t(ser_readdata32(s)); }
void Unserialize<DataStream>(DataStream&, int&)
Line
Count
Source
269
659k
template <typename Stream> void Unserialize(Stream& s, int32_t& a)   { a = int32_t(ser_readdata32(s)); }
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, int&)
Line
Count
Source
269
34.2k
template <typename Stream> void Unserialize(Stream& s, int32_t& a)   { a = int32_t(ser_readdata32(s)); }
void Unserialize<AutoFile>(AutoFile&, int&)
Line
Count
Source
269
1.19k
template <typename Stream> void Unserialize(Stream& s, int32_t& a)   { a = int32_t(ser_readdata32(s)); }
void Unserialize<SpanReader>(SpanReader&, int&)
Line
Count
Source
269
2.90k
template <typename Stream> void Unserialize(Stream& s, int32_t& a)   { a = int32_t(ser_readdata32(s)); }
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&, int&)
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, int&)
Line
Count
Source
269
691k
template <typename Stream> void Unserialize(Stream& s, int32_t& a)   { a = int32_t(ser_readdata32(s)); }
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, int&)
Line
Count
Source
269
6.18k
template <typename Stream> void Unserialize(Stream& s, int32_t& a)   { a = int32_t(ser_readdata32(s)); }
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, int&)
Line
Count
Source
269
1.03k
template <typename Stream> void Unserialize(Stream& s, int32_t& a)   { a = int32_t(ser_readdata32(s)); }
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&, int&)
Line
Count
Source
269
140k
template <typename Stream> void Unserialize(Stream& s, int32_t& a)   { a = int32_t(ser_readdata32(s)); }
void Unserialize<BufferedFile>(BufferedFile&, int&)
Line
Count
Source
269
2.02k
template <typename Stream> void Unserialize(Stream& s, int32_t& a)   { a = int32_t(ser_readdata32(s)); }
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&, int&)
Line
Count
Source
269
1.91k
template <typename Stream> void Unserialize(Stream& s, int32_t& a)   { a = int32_t(ser_readdata32(s)); }
270
4.66M
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
void Unserialize<DataStream>(DataStream&, unsigned int&)
Line
Count
Source
270
2.22M
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, unsigned int&)
Line
Count
Source
270
606k
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
void Unserialize<SpanReader>(SpanReader&, unsigned int&)
Line
Count
Source
270
43.7k
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
void Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&, unsigned int&)
Line
Count
Source
270
7
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
void Unserialize<AutoFile>(AutoFile&, unsigned int&)
Line
Count
Source
270
153k
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&, unsigned int&)
Line
Count
Source
270
1.56M
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
void Unserialize<BufferedReader<AutoFile>>(BufferedReader<AutoFile>&, unsigned int&)
Line
Count
Source
270
2
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, unsigned int&)
Line
Count
Source
270
41.0k
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&, unsigned int&)
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned int&)
Line
Count
Source
270
6.93k
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, unsigned int&)
Line
Count
Source
270
9
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, unsigned int&)
Line
Count
Source
270
2.03k
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
void Unserialize<BufferedFile>(BufferedFile&, unsigned int&)
Line
Count
Source
270
8.10k
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&, unsigned int&)
Line
Count
Source
270
13.7k
template <typename Stream> void Unserialize(Stream& s, uint32_t& a)  { a = ser_readdata32(s); }
271
855k
template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, long&)
Line
Count
Source
271
289k
template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
void Unserialize<DataStream>(DataStream&, long&)
Line
Count
Source
271
8.86k
template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
void Unserialize<SpanReader>(SpanReader&, long&)
Line
Count
Source
271
9.18k
template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&, long&)
Line
Count
Source
271
521k
template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&, long&)
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, long&)
Line
Count
Source
271
20.5k
template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, long&)
Line
Count
Source
271
13
template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, long&)
Line
Count
Source
271
4
template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, long&)
Line
Count
Source
271
832
template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
void Unserialize<AutoFile>(AutoFile&, long&)
Line
Count
Source
271
666
template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&, long&)
Line
Count
Source
271
3.96k
template <typename Stream> void Unserialize(Stream& s, int64_t& a)   { a = int64_t(ser_readdata64(s)); }
272
22.5M
template <typename Stream> void Unserialize(Stream& s, uint64_t& a)  { a = ser_readdata64(s); }
void Unserialize<DataStream>(DataStream&, unsigned long&)
Line
Count
Source
272
40.6k
template <typename Stream> void Unserialize(Stream& s, uint64_t& a)  { a = ser_readdata64(s); }
void Unserialize<SpanReader>(SpanReader&, unsigned long&)
Line
Count
Source
272
3.63k
template <typename Stream> void Unserialize(Stream& s, uint64_t& a)  { a = ser_readdata64(s); }
void Unserialize<AutoFile>(AutoFile&, unsigned long&)
Line
Count
Source
272
22.4M
template <typename Stream> void Unserialize(Stream& s, uint64_t& a)  { a = ser_readdata64(s); }
273
274
270k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<DataStream, unsigned char, 4ul>(DataStream&, unsigned char (&) [4ul])
Line
Count
Source
274
129k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, unsigned char, 16ul>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned char (&) [16ul])
Line
Count
Source
274
1
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char, 16ul>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char (&) [16ul])
Line
Count
Source
274
4
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<DataStream, char, 16ul>(DataStream&, char (&) [16ul])
Line
Count
Source
274
3
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<BufferedFile, unsigned char, 29ul>(BufferedFile&, unsigned char (&) [29ul])
Line
Count
Source
274
1
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<BufferedFile, unsigned char, 1ul>(BufferedFile&, unsigned char (&) [1ul])
Line
Count
Source
274
644
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<BufferedFile, unsigned char, 2ul>(BufferedFile&, unsigned char (&) [2ul])
Line
Count
Source
274
635
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<BufferedFile, unsigned char, 5ul>(BufferedFile&, unsigned char (&) [5ul])
Line
Count
Source
274
647
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<DataStream, unsigned char, 5ul>(DataStream&, unsigned char (&) [5ul])
Line
Count
Source
274
1
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<SpanReader, unsigned char, 4ul>(SpanReader&, unsigned char (&) [4ul])
Line
Count
Source
274
11
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
Unexecuted instantiation: void Unserialize<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char, 16ul>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char (&) [16ul])
Unexecuted instantiation: void Unserialize<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char, 16ul>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char (&) [16ul])
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>, unsigned char, 16ul>(ParamsStream<AutoFile&, CAddress::SerParams>&, unsigned char (&) [16ul])
Unexecuted instantiation: void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, unsigned char, 16ul>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, unsigned char (&) [16ul])
void Unserialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char, 16ul>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char (&) [16ul])
Line
Count
Source
274
5.88k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char, 16ul>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned char (&) [16ul])
Line
Count
Source
274
1
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, unsigned char, 16ul>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, unsigned char (&) [16ul])
Line
Count
Source
274
1
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
Unexecuted instantiation: void Unserialize<ParamsStream<SpanReader, CAddress::SerParams>, unsigned char, 16ul>(ParamsStream<SpanReader, CAddress::SerParams>&, unsigned char (&) [16ul])
void Unserialize<DataStream, char, 12ul>(DataStream&, char (&) [12ul])
Line
Count
Source
274
129k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<ParamsStream<DataStream&, CNetAddr::SerParams>, unsigned char, 16ul>(ParamsStream<DataStream&, CNetAddr::SerParams>&, unsigned char (&) [16ul])
Line
Count
Source
274
1.73k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<AutoFile, char, 368ul>(AutoFile&, char (&) [368ul])
Line
Count
Source
274
104
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<AutoFile, char, 12ul>(AutoFile&, char (&) [12ul])
Line
Count
Source
274
104
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<AutoFile, unsigned char, 20ul>(AutoFile&, unsigned char (&) [20ul])
Line
Count
Source
274
104
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<AutoFile, unsigned char, 16ul>(AutoFile&, unsigned char (&) [16ul])
Line
Count
Source
274
104
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
void Unserialize<SpanReader, unsigned char, 5ul>(SpanReader&, unsigned char (&) [5ul])
Line
Count
Source
274
1.87k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, B (&a)[N])            { s.read(MakeWritableByteSpan(a)); }
275
320k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
void Unserialize<DataStream, unsigned char, 4ul>(DataStream&, std::array<unsigned char, 4ul>&)
Line
Count
Source
275
135k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
void Unserialize<DataStream, unsigned char, 33ul>(DataStream&, std::array<unsigned char, 33ul>&)
Line
Count
Source
275
5.78k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
void Unserialize<DataStream, unsigned char, 32ul>(DataStream&, std::array<unsigned char, 32ul>&)
Line
Count
Source
275
1
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
void Unserialize<AutoFile, unsigned char, 5ul>(AutoFile&, std::array<unsigned char, 5ul>&)
Line
Count
Source
275
73
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
void Unserialize<AutoFile, unsigned char, 4ul>(AutoFile&, std::array<unsigned char, 4ul>&)
Line
Count
Source
275
146k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
void Unserialize<SpanReader, unsigned char, 4ul>(SpanReader&, std::array<unsigned char, 4ul>&)
Line
Count
Source
275
20.5k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
void Unserialize<SpanReader, unsigned char, 33ul>(SpanReader&, std::array<unsigned char, 33ul>&)
Line
Count
Source
275
8.45k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
void Unserialize<HashVerifier<DataStream>, unsigned char, 4ul>(HashVerifier<DataStream>&, std::array<unsigned char, 4ul>&)
Line
Count
Source
275
2
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
void Unserialize<HashVerifier<AutoFile>, unsigned char, 4ul>(HashVerifier<AutoFile>&, std::array<unsigned char, 4ul>&)
Line
Count
Source
275
671
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
void Unserialize<AutoFile, std::byte, 8ul>(AutoFile&, std::array<std::byte, 8ul>&)
Line
Count
Source
275
844
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
void Unserialize<BufferedFile, unsigned char, 4ul>(BufferedFile&, std::array<unsigned char, 4ul>&)
Line
Count
Source
275
2.02k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
void Unserialize<AutoFile, std::byte, 20ul>(AutoFile&, std::array<std::byte, 20ul>&)
Line
Count
Source
275
104
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::array<B, N>& a)  { s.read(MakeWritableByteSpan(a)); }
276
11.6k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::span<B, N> span) { s.read(std::as_writable_bytes(span)); }
void Unserialize<DataStream, unsigned char, 33ul>(DataStream&, std::span<unsigned char, 33ul>)
Line
Count
Source
276
1
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::span<B, N> span) { s.read(std::as_writable_bytes(span)); }
void Unserialize<DataStream, std::byte, 2ul>(DataStream&, std::span<std::byte, 2ul>)
Line
Count
Source
276
1
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::span<B, N> span) { s.read(std::as_writable_bytes(span)); }
void Unserialize<SpanReader, std::byte, 33ul>(SpanReader&, std::span<std::byte, 33ul>)
Line
Count
Source
276
11.6k
template <typename Stream, BasicByte B, size_t N> void Unserialize(Stream& s, std::span<B, N> span) { s.read(std::as_writable_bytes(span)); }
277
453k
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
void Unserialize<DataStream, unsigned char>(DataStream&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
277
283k
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
void Unserialize<SpanReader, unsigned char>(SpanReader&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
277
90.5k
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, unsigned char>(ParamsStream<DataStream&, CAddress::SerParams>&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
277
22
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
void Unserialize<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
277
3
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
Unexecuted instantiation: void Unserialize<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>, char>(ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, std::span<char, 18446744073709551615ul>)
Unexecuted instantiation: void Unserialize<ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, char>(ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>&, std::span<char, 18446744073709551615ul>)
void Unserialize<ParamsStream<DataStream&, serialize_tests::BaseFormat>, char>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, std::span<char, 18446744073709551615ul>)
Line
Count
Source
277
3
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
void Unserialize<AutoFile, std::byte>(AutoFile&, std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
277
1
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
void Unserialize<AutoFile, unsigned char>(AutoFile&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
277
6.35k
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
void Unserialize<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
277
20.5k
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
Unexecuted instantiation: void Unserialize<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&, std::span<unsigned char, 18446744073709551615ul>)
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>, unsigned char>(ParamsStream<AutoFile&, CAddress::SerParams>&, std::span<unsigned char, 18446744073709551615ul>)
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, unsigned char>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
277
20.5k
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
void Unserialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
277
1.03k
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
void Unserialize<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned char>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
277
3
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, unsigned char>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
277
3
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
Unexecuted instantiation: void Unserialize<ParamsStream<SpanReader, CAddress::SerParams>, unsigned char>(ParamsStream<SpanReader, CAddress::SerParams>&, std::span<unsigned char, 18446744073709551615ul>)
Unexecuted instantiation: void Unserialize<ParamsStream<DataStream&, CNetAddr::SerParams>, unsigned char>(ParamsStream<DataStream&, CNetAddr::SerParams>&, std::span<unsigned char, 18446744073709551615ul>)
void Unserialize<HashVerifier<BufferedReader<AutoFile>>, unsigned char>(HashVerifier<BufferedReader<AutoFile>>&, std::span<unsigned char, 18446744073709551615ul>)
Line
Count
Source
277
31.1k
template <typename Stream, BasicByte B>           void Unserialize(Stream& s, std::span<B> span)    { s.read(std::as_writable_bytes(span)); }
278
279
53.1k
template <typename Stream> void Serialize(Stream& s, bool a)    { uint8_t f = a; ser_writedata8(s, f); }
void Serialize<DataStream>(DataStream&, bool)
Line
Count
Source
279
49.4k
template <typename Stream> void Serialize(Stream& s, bool a)    { uint8_t f = a; ser_writedata8(s, f); }
void Serialize<SizeComputer>(SizeComputer&, bool)
Line
Count
Source
279
2
template <typename Stream> void Serialize(Stream& s, bool a)    { uint8_t f = a; ser_writedata8(s, f); }
void Serialize<HashWriter>(HashWriter&, bool)
Line
Count
Source
279
27
template <typename Stream> void Serialize(Stream& s, bool a)    { uint8_t f = a; ser_writedata8(s, f); }
void Serialize<VectorWriter>(VectorWriter&, bool)
Line
Count
Source
279
3.72k
template <typename Stream> void Serialize(Stream& s, bool a)    { uint8_t f = a; ser_writedata8(s, f); }
280
24.9k
template <typename Stream> void Unserialize(Stream& s, bool& a) { uint8_t f = ser_readdata8(s); a = f; }
void Unserialize<SpanReader>(SpanReader&, bool&)
Line
Count
Source
280
4
template <typename Stream> void Unserialize(Stream& s, bool& a) { uint8_t f = ser_readdata8(s); a = f; }
void Unserialize<DataStream>(DataStream&, bool&)
Line
Count
Source
280
24.9k
template <typename Stream> void Unserialize(Stream& s, bool& a) { uint8_t f = ser_readdata8(s); a = f; }
281
// clang-format on
282
283
284
/**
285
 * Compact Size
286
 * size <  253        -- 1 byte
287
 * size <= USHRT_MAX  -- 3 bytes  (253 + 2 bytes)
288
 * size <= UINT_MAX   -- 5 bytes  (254 + 4 bytes)
289
 * size >  UINT_MAX   -- 9 bytes  (255 + 8 bytes)
290
 */
291
constexpr inline unsigned int GetSizeOfCompactSize(uint64_t nSize)
292
8.59M
{
293
8.59M
    if (nSize < 253)             return sizeof(unsigned char);
294
6.32M
    else if (nSize <= std::numeric_limits<uint16_t>::max()) return sizeof(unsigned char) + sizeof(uint16_t);
295
6.30M
    else if (nSize <= std::numeric_limits<unsigned int>::max())  return sizeof(unsigned char) + sizeof(unsigned int);
296
18.4E
    else                         return sizeof(unsigned char) + sizeof(uint64_t);
297
8.59M
}
298
299
inline void WriteCompactSize(SizeComputer& os, uint64_t nSize);
300
301
template<typename Stream>
302
void WriteCompactSize(Stream& os, uint64_t nSize)
303
63.3M
{
304
63.3M
    if (nSize < 253)
305
63.1M
    {
306
63.1M
        ser_writedata8(os, nSize);
307
63.1M
    }
308
191k
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
83.4k
    {
310
83.4k
        ser_writedata8(os, 253);
311
83.4k
        ser_writedata16(os, nSize);
312
83.4k
    }
313
107k
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
107k
    {
315
107k
        ser_writedata8(os, 254);
316
107k
        ser_writedata32(os, nSize);
317
107k
    }
318
18.4E
    else
319
18.4E
    {
320
18.4E
        ser_writedata8(os, 255);
321
18.4E
        ser_writedata64(os, nSize);
322
18.4E
    }
323
63.3M
    return;
324
63.3M
}
void WriteCompactSize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&, unsigned long)
Line
Count
Source
303
25.9M
{
304
25.9M
    if (nSize < 253)
305
25.8M
    {
306
25.8M
        ser_writedata8(os, nSize);
307
25.8M
    }
308
104k
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
39.7k
    {
310
39.7k
        ser_writedata8(os, 253);
311
39.7k
        ser_writedata16(os, nSize);
312
39.7k
    }
313
64.4k
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
64.5k
    {
315
64.5k
        ser_writedata8(os, 254);
316
64.5k
        ser_writedata32(os, nSize);
317
64.5k
    }
318
18.4E
    else
319
18.4E
    {
320
18.4E
        ser_writedata8(os, 255);
321
18.4E
        ser_writedata64(os, nSize);
322
18.4E
    }
323
25.9M
    return;
324
25.9M
}
void WriteCompactSize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned long)
Line
Count
Source
303
40
{
304
40
    if (nSize < 253)
305
39
    {
306
39
        ser_writedata8(os, nSize);
307
39
    }
308
1
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
1
    {
310
1
        ser_writedata8(os, 253);
311
1
        ser_writedata16(os, nSize);
312
1
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
40
    return;
324
40
}
void WriteCompactSize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long)
Line
Count
Source
303
18
{
304
18
    if (nSize < 253)
305
18
    {
306
18
        ser_writedata8(os, nSize);
307
18
    }
308
0
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
0
    {
310
0
        ser_writedata8(os, 253);
311
0
        ser_writedata16(os, nSize);
312
0
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
18
    return;
324
18
}
void WriteCompactSize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, unsigned long)
Line
Count
Source
303
1.09M
{
304
1.09M
    if (nSize < 253)
305
1.09M
    {
306
1.09M
        ser_writedata8(os, nSize);
307
1.09M
    }
308
1.95k
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
347
    {
310
347
        ser_writedata8(os, 253);
311
347
        ser_writedata16(os, nSize);
312
347
    }
313
1.60k
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
1.60k
    {
315
1.60k
        ser_writedata8(os, 254);
316
1.60k
        ser_writedata32(os, nSize);
317
1.60k
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
1.09M
    return;
324
1.09M
}
void WriteCompactSize<DataStream>(DataStream&, unsigned long)
Line
Count
Source
303
1.51M
{
304
1.51M
    if (nSize < 253)
305
1.51M
    {
306
1.51M
        ser_writedata8(os, nSize);
307
1.51M
    }
308
2.68k
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
2.66k
    {
310
2.66k
        ser_writedata8(os, 253);
311
2.66k
        ser_writedata16(os, nSize);
312
2.66k
    }
313
26
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
26
    {
315
26
        ser_writedata8(os, 254);
316
26
        ser_writedata32(os, nSize);
317
26
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
1.51M
    return;
324
1.51M
}
void WriteCompactSize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&, unsigned long)
Line
Count
Source
303
558k
{
304
558k
    if (nSize < 253)
305
542k
    {
306
542k
        ser_writedata8(os, nSize);
307
542k
    }
308
15.9k
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
131
    {
310
131
        ser_writedata8(os, 253);
311
131
        ser_writedata16(os, nSize);
312
131
    }
313
15.8k
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
15.8k
    {
315
15.8k
        ser_writedata8(os, 254);
316
15.8k
        ser_writedata32(os, nSize);
317
15.8k
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
558k
    return;
324
558k
}
void WriteCompactSize<AutoFile>(AutoFile&, unsigned long)
Line
Count
Source
303
213k
{
304
213k
    if (nSize < 253)
305
213k
    {
306
213k
        ser_writedata8(os, nSize);
307
213k
    }
308
0
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
0
    {
310
0
        ser_writedata8(os, 253);
311
0
        ser_writedata16(os, nSize);
312
0
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
213k
    return;
324
213k
}
void WriteCompactSize<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&, unsigned long)
Line
Count
Source
303
14.8M
{
304
14.8M
    if (nSize < 253)
305
14.8M
    {
306
14.8M
        ser_writedata8(os, nSize);
307
14.8M
    }
308
41.5k
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
21.2k
    {
310
21.2k
        ser_writedata8(os, 253);
311
21.2k
        ser_writedata16(os, nSize);
312
21.2k
    }
313
20.3k
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
20.3k
    {
315
20.3k
        ser_writedata8(os, 254);
316
20.3k
        ser_writedata32(os, nSize);
317
20.3k
    }
318
18.4E
    else
319
18.4E
    {
320
18.4E
        ser_writedata8(os, 255);
321
18.4E
        ser_writedata64(os, nSize);
322
18.4E
    }
323
14.8M
    return;
324
14.8M
}
void WriteCompactSize<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned long)
Line
Count
Source
303
167
{
304
167
    if (nSize < 253)
305
136
    {
306
136
        ser_writedata8(os, nSize);
307
136
    }
308
31
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
31
    {
310
31
        ser_writedata8(os, 253);
311
31
        ser_writedata16(os, nSize);
312
31
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
167
    return;
324
167
}
void WriteCompactSize<HashWriter>(HashWriter&, unsigned long)
Line
Count
Source
303
16.4M
{
304
16.4M
    if (nSize < 253)
305
16.4M
    {
306
16.4M
        ser_writedata8(os, nSize);
307
16.4M
    }
308
15.2k
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
12.2k
    {
310
12.2k
        ser_writedata8(os, 253);
311
12.2k
        ser_writedata16(os, nSize);
312
12.2k
    }
313
3.05k
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
3.05k
    {
315
3.05k
        ser_writedata8(os, 254);
316
3.05k
        ser_writedata32(os, nSize);
317
3.05k
    }
318
18.4E
    else
319
18.4E
    {
320
18.4E
        ser_writedata8(os, 255);
321
18.4E
        ser_writedata64(os, nSize);
322
18.4E
    }
323
16.4M
    return;
324
16.4M
}
void WriteCompactSize<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, unsigned long)
Line
Count
Source
303
2
{
304
2
    if (nSize < 253)
305
2
    {
306
2
        ser_writedata8(os, nSize);
307
2
    }
308
0
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
0
    {
310
0
        ser_writedata8(os, 253);
311
0
        ser_writedata16(os, nSize);
312
0
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
2
    return;
324
2
}
void WriteCompactSize<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, unsigned long)
Line
Count
Source
303
2
{
304
2
    if (nSize < 253)
305
2
    {
306
2
        ser_writedata8(os, nSize);
307
2
    }
308
0
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
0
    {
310
0
        ser_writedata8(os, 253);
311
0
        ser_writedata16(os, nSize);
312
0
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
2
    return;
324
2
}
void WriteCompactSize<HashedSourceWriter<DataStream>>(HashedSourceWriter<DataStream>&, unsigned long)
Line
Count
Source
303
1
{
304
1
    if (nSize < 253)
305
1
    {
306
1
        ser_writedata8(os, nSize);
307
1
    }
308
0
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
0
    {
310
0
        ser_writedata8(os, 253);
311
0
        ser_writedata16(os, nSize);
312
0
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
1
    return;
324
1
}
void WriteCompactSize<SizeComputer>(SizeComputer&, unsigned long)
Line
Count
Source
303
58.2k
{
304
58.2k
    if (nSize < 253)
305
58.2k
    {
306
58.2k
        ser_writedata8(os, nSize);
307
58.2k
    }
308
1
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
1
    {
310
1
        ser_writedata8(os, 253);
311
1
        ser_writedata16(os, nSize);
312
1
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
58.2k
    return;
324
58.2k
}
void WriteCompactSize<VectorWriter>(VectorWriter&, unsigned long)
Line
Count
Source
303
136k
{
304
136k
    if (nSize < 253)
305
136k
    {
306
136k
        ser_writedata8(os, nSize);
307
136k
    }
308
30
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
30
    {
310
30
        ser_writedata8(os, 253);
311
30
        ser_writedata16(os, nSize);
312
30
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
136k
    return;
324
136k
}
Unexecuted instantiation: void WriteCompactSize<ParamsStream<VectorWriter&, CNetAddr::SerParams>>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, unsigned long)
void WriteCompactSize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, unsigned long)
Line
Count
Source
303
100k
{
304
100k
    if (nSize < 253)
305
100k
    {
306
100k
        ser_writedata8(os, nSize);
307
100k
    }
308
40
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
40
    {
310
40
        ser_writedata8(os, 253);
311
40
        ser_writedata16(os, nSize);
312
40
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
100k
    return;
324
100k
}
void WriteCompactSize<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long)
Line
Count
Source
303
50.3k
{
304
50.3k
    if (nSize < 253)
305
50.3k
    {
306
50.3k
        ser_writedata8(os, nSize);
307
50.3k
    }
308
0
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
0
    {
310
0
        ser_writedata8(os, 253);
311
0
        ser_writedata16(os, nSize);
312
0
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
50.3k
    return;
324
50.3k
}
void WriteCompactSize<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long)
Line
Count
Source
303
33
{
304
33
    if (nSize < 253)
305
33
    {
306
33
        ser_writedata8(os, nSize);
307
33
    }
308
0
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
0
    {
310
0
        ser_writedata8(os, 253);
311
0
        ser_writedata16(os, nSize);
312
0
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
33
    return;
324
33
}
void WriteCompactSize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&, unsigned long)
Line
Count
Source
303
145k
{
304
145k
    if (nSize < 253)
305
145k
    {
306
145k
        ser_writedata8(os, nSize);
307
145k
    }
308
14
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
14
    {
310
14
        ser_writedata8(os, 253);
311
14
        ser_writedata16(os, nSize);
312
14
    }
313
0
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
0
    {
315
0
        ser_writedata8(os, 254);
316
0
        ser_writedata32(os, nSize);
317
0
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
145k
    return;
324
145k
}
void WriteCompactSize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, unsigned long)
Line
Count
Source
303
2.15M
{
304
2.15M
    if (nSize < 253)
305
2.14M
    {
306
2.14M
        ser_writedata8(os, nSize);
307
2.14M
    }
308
8.85k
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
7.02k
    {
310
7.02k
        ser_writedata8(os, 253);
311
7.02k
        ser_writedata16(os, nSize);
312
7.02k
    }
313
1.82k
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
1.82k
    {
315
1.82k
        ser_writedata8(os, 254);
316
1.82k
        ser_writedata32(os, nSize);
317
1.82k
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
2.15M
    return;
324
2.15M
}
void WriteCompactSize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, unsigned long)
Line
Count
Source
303
14.5k
{
304
14.5k
    if (nSize < 253)
305
14.1k
    {
306
14.1k
        ser_writedata8(os, nSize);
307
14.1k
    }
308
438
    else if (nSize <= std::numeric_limits<uint16_t>::max())
309
13
    {
310
13
        ser_writedata8(os, 253);
311
13
        ser_writedata16(os, nSize);
312
13
    }
313
425
    else if (nSize <= std::numeric_limits<unsigned int>::max())
314
425
    {
315
425
        ser_writedata8(os, 254);
316
425
        ser_writedata32(os, nSize);
317
425
    }
318
0
    else
319
0
    {
320
0
        ser_writedata8(os, 255);
321
0
        ser_writedata64(os, nSize);
322
0
    }
323
14.5k
    return;
324
14.5k
}
325
326
/**
327
 * Decode a CompactSize-encoded variable-length integer.
328
 *
329
 * As these are primarily used to encode the size of vector-like serializations, by default a range
330
 * check is performed. When used as a generic number encoding, range_check should be set to false.
331
 */
332
template<typename Stream>
333
uint64_t ReadCompactSize(Stream& is, bool range_check = true)
334
6.10M
{
335
6.10M
    uint8_t chSize = ser_readdata8(is);
336
6.10M
    uint64_t nSizeRet = 0;
337
6.10M
    if (chSize < 253)
338
6.07M
    {
339
6.07M
        nSizeRet = chSize;
340
6.07M
    }
341
21.7k
    else if (chSize == 253)
342
11.4k
    {
343
11.4k
        nSizeRet = ser_readdata16(is);
344
11.4k
        if (nSizeRet < 253)
345
2
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
11.4k
    }
347
10.2k
    else if (chSize == 254)
348
10.2k
    {
349
10.2k
        nSizeRet = ser_readdata32(is);
350
10.2k
        if (nSizeRet < 0x10000u)
351
2
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
10.2k
    }
353
21
    else
354
21
    {
355
21
        nSizeRet = ser_readdata64(is);
356
21
        if (nSizeRet < 0x100000000ULL)
357
3
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
21
    }
359
6.10M
    if (range_check && nSizeRet > MAX_SIZE) {
360
3
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
3
    }
362
6.10M
    return nSizeRet;
363
6.10M
}
unsigned long ReadCompactSize<SpanReader>(SpanReader&, bool)
Line
Count
Source
334
167k
{
335
167k
    uint8_t chSize = ser_readdata8(is);
336
167k
    uint64_t nSizeRet = 0;
337
167k
    if (chSize < 253)
338
166k
    {
339
166k
        nSizeRet = chSize;
340
166k
    }
341
276
    else if (chSize == 253)
342
272
    {
343
272
        nSizeRet = ser_readdata16(is);
344
272
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
272
    }
347
4
    else if (chSize == 254)
348
2
    {
349
2
        nSizeRet = ser_readdata32(is);
350
2
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
2
    }
353
2
    else
354
2
    {
355
2
        nSizeRet = ser_readdata64(is);
356
2
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
2
    }
359
167k
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
167k
    return nSizeRet;
363
167k
}
unsigned long ReadCompactSize<DataStream>(DataStream&, bool)
Line
Count
Source
334
774k
{
335
774k
    uint8_t chSize = ser_readdata8(is);
336
774k
    uint64_t nSizeRet = 0;
337
774k
    if (chSize < 253)
338
774k
    {
339
774k
        nSizeRet = chSize;
340
774k
    }
341
545
    else if (chSize == 253)
342
522
    {
343
522
        nSizeRet = ser_readdata16(is);
344
522
        if (nSizeRet < 253)
345
2
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
522
    }
347
23
    else if (chSize == 254)
348
21
    {
349
21
        nSizeRet = ser_readdata32(is);
350
21
        if (nSizeRet < 0x10000u)
351
2
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
21
    }
353
2
    else
354
2
    {
355
2
        nSizeRet = ser_readdata64(is);
356
2
        if (nSizeRet < 0x100000000ULL)
357
2
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
2
    }
359
774k
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
774k
    return nSizeRet;
363
774k
}
unsigned long ReadCompactSize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&, bool)
Line
Count
Source
334
1.05M
{
335
1.05M
    uint8_t chSize = ser_readdata8(is);
336
1.05M
    uint64_t nSizeRet = 0;
337
1.05M
    if (chSize < 253)
338
1.04M
    {
339
1.04M
        nSizeRet = chSize;
340
1.04M
    }
341
1.67k
    else if (chSize == 253)
342
277
    {
343
277
        nSizeRet = ser_readdata16(is);
344
277
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
277
    }
347
1.39k
    else if (chSize == 254)
348
1.39k
    {
349
1.39k
        nSizeRet = ser_readdata32(is);
350
1.39k
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
1.39k
    }
353
1
    else
354
1
    {
355
1
        nSizeRet = ser_readdata64(is);
356
1
        if (nSizeRet < 0x100000000ULL)
357
1
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
1
    }
359
1.05M
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
1.05M
    return nSizeRet;
363
1.05M
}
unsigned long ReadCompactSize<AutoFile>(AutoFile&, bool)
Line
Count
Source
334
114k
{
335
114k
    uint8_t chSize = ser_readdata8(is);
336
114k
    uint64_t nSizeRet = 0;
337
114k
    if (chSize < 253)
338
114k
    {
339
114k
        nSizeRet = chSize;
340
114k
    }
341
3
    else if (chSize == 253)
342
1
    {
343
1
        nSizeRet = ser_readdata16(is);
344
1
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
1
    }
347
2
    else if (chSize == 254)
348
0
    {
349
0
        nSizeRet = ser_readdata32(is);
350
0
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
0
    }
353
2
    else
354
2
    {
355
2
        nSizeRet = ser_readdata64(is);
356
2
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
2
    }
359
114k
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
114k
    return nSizeRet;
363
114k
}
unsigned long ReadCompactSize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&, bool)
Line
Count
Source
334
1.12k
{
335
1.12k
    uint8_t chSize = ser_readdata8(is);
336
1.12k
    uint64_t nSizeRet = 0;
337
1.12k
    if (chSize < 253)
338
1.10k
    {
339
1.10k
        nSizeRet = chSize;
340
1.10k
    }
341
17
    else if (chSize == 253)
342
9
    {
343
9
        nSizeRet = ser_readdata16(is);
344
9
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
9
    }
347
8
    else if (chSize == 254)
348
1
    {
349
1
        nSizeRet = ser_readdata32(is);
350
1
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
1
    }
353
7
    else
354
7
    {
355
7
        nSizeRet = ser_readdata64(is);
356
7
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
7
    }
359
1.12k
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
1.12k
    return nSizeRet;
363
1.12k
}
unsigned long ReadCompactSize<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&, bool)
Line
Count
Source
334
6
{
335
6
    uint8_t chSize = ser_readdata8(is);
336
6
    uint64_t nSizeRet = 0;
337
6
    if (chSize < 253)
338
5
    {
339
5
        nSizeRet = chSize;
340
5
    }
341
1
    else if (chSize == 253)
342
1
    {
343
1
        nSizeRet = ser_readdata16(is);
344
1
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
1
    }
347
0
    else if (chSize == 254)
348
0
    {
349
0
        nSizeRet = ser_readdata32(is);
350
0
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
0
    }
353
0
    else
354
0
    {
355
0
        nSizeRet = ser_readdata64(is);
356
0
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
0
    }
359
6
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
6
    return nSizeRet;
363
6
}
unsigned long ReadCompactSize<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&, bool)
Line
Count
Source
334
3
{
335
3
    uint8_t chSize = ser_readdata8(is);
336
3
    uint64_t nSizeRet = 0;
337
3
    if (chSize < 253)
338
3
    {
339
3
        nSizeRet = chSize;
340
3
    }
341
0
    else if (chSize == 253)
342
0
    {
343
0
        nSizeRet = ser_readdata16(is);
344
0
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
0
    }
347
0
    else if (chSize == 254)
348
0
    {
349
0
        nSizeRet = ser_readdata32(is);
350
0
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
0
    }
353
0
    else
354
0
    {
355
0
        nSizeRet = ser_readdata64(is);
356
0
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
0
    }
359
3
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
3
    return nSizeRet;
363
3
}
unsigned long ReadCompactSize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&, bool)
Line
Count
Source
334
3.85M
{
335
3.85M
    uint8_t chSize = ser_readdata8(is);
336
3.85M
    uint64_t nSizeRet = 0;
337
3.85M
    if (chSize < 253)
338
3.83M
    {
339
3.83M
        nSizeRet = chSize;
340
3.83M
    }
341
19.0k
    else if (chSize == 253)
342
10.3k
    {
343
10.3k
        nSizeRet = ser_readdata16(is);
344
10.3k
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
10.3k
    }
347
8.71k
    else if (chSize == 254)
348
8.70k
    {
349
8.70k
        nSizeRet = ser_readdata32(is);
350
8.70k
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
8.70k
    }
353
6
    else
354
6
    {
355
6
        nSizeRet = ser_readdata64(is);
356
6
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
6
    }
359
3.85M
    if (range_check && nSizeRet > MAX_SIZE) {
360
3
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
3
    }
362
3.85M
    return nSizeRet;
363
3.85M
}
unsigned long ReadCompactSize<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, bool)
Line
Count
Source
334
2
{
335
2
    uint8_t chSize = ser_readdata8(is);
336
2
    uint64_t nSizeRet = 0;
337
2
    if (chSize < 253)
338
2
    {
339
2
        nSizeRet = chSize;
340
2
    }
341
0
    else if (chSize == 253)
342
0
    {
343
0
        nSizeRet = ser_readdata16(is);
344
0
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
0
    }
347
0
    else if (chSize == 254)
348
0
    {
349
0
        nSizeRet = ser_readdata32(is);
350
0
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
0
    }
353
0
    else
354
0
    {
355
0
        nSizeRet = ser_readdata64(is);
356
0
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
0
    }
359
2
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
2
    return nSizeRet;
363
2
}
Unexecuted instantiation: unsigned long ReadCompactSize<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, bool)
unsigned long ReadCompactSize<HashVerifier<DataStream>>(HashVerifier<DataStream>&, bool)
Line
Count
Source
334
1
{
335
1
    uint8_t chSize = ser_readdata8(is);
336
1
    uint64_t nSizeRet = 0;
337
1
    if (chSize < 253)
338
1
    {
339
1
        nSizeRet = chSize;
340
1
    }
341
0
    else if (chSize == 253)
342
0
    {
343
0
        nSizeRet = ser_readdata16(is);
344
0
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
0
    }
347
0
    else if (chSize == 254)
348
0
    {
349
0
        nSizeRet = ser_readdata32(is);
350
0
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
0
    }
353
0
    else
354
0
    {
355
0
        nSizeRet = ser_readdata64(is);
356
0
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
0
    }
359
1
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
1
    return nSizeRet;
363
1
}
unsigned long ReadCompactSize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, bool)
Line
Count
Source
334
41.1k
{
335
41.1k
    uint8_t chSize = ser_readdata8(is);
336
41.1k
    uint64_t nSizeRet = 0;
337
41.1k
    if (chSize < 253)
338
41.0k
    {
339
41.0k
        nSizeRet = chSize;
340
41.0k
    }
341
20
    else if (chSize == 253)
342
20
    {
343
20
        nSizeRet = ser_readdata16(is);
344
20
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
20
    }
347
0
    else if (chSize == 254)
348
0
    {
349
0
        nSizeRet = ser_readdata32(is);
350
0
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
0
    }
353
0
    else
354
0
    {
355
0
        nSizeRet = ser_readdata64(is);
356
0
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
0
    }
359
41.1k
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
41.1k
    return nSizeRet;
363
41.1k
}
unsigned long ReadCompactSize<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, bool)
Line
Count
Source
334
20.5k
{
335
20.5k
    uint8_t chSize = ser_readdata8(is);
336
20.5k
    uint64_t nSizeRet = 0;
337
20.5k
    if (chSize < 253)
338
20.5k
    {
339
20.5k
        nSizeRet = chSize;
340
20.5k
    }
341
0
    else if (chSize == 253)
342
0
    {
343
0
        nSizeRet = ser_readdata16(is);
344
0
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
0
    }
347
0
    else if (chSize == 254)
348
0
    {
349
0
        nSizeRet = ser_readdata32(is);
350
0
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
0
    }
353
0
    else
354
0
    {
355
0
        nSizeRet = ser_readdata64(is);
356
0
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
0
    }
359
20.5k
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
20.5k
    return nSizeRet;
363
20.5k
}
Unexecuted instantiation: unsigned long ReadCompactSize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&, bool)
Unexecuted instantiation: unsigned long ReadCompactSize<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&, bool)
unsigned long ReadCompactSize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, bool)
Line
Count
Source
334
1.03k
{
335
1.03k
    uint8_t chSize = ser_readdata8(is);
336
1.03k
    uint64_t nSizeRet = 0;
337
1.03k
    if (chSize < 253)
338
1.03k
    {
339
1.03k
        nSizeRet = chSize;
340
1.03k
    }
341
1
    else if (chSize == 253)
342
1
    {
343
1
        nSizeRet = ser_readdata16(is);
344
1
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
1
    }
347
0
    else if (chSize == 254)
348
0
    {
349
0
        nSizeRet = ser_readdata32(is);
350
0
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
0
    }
353
0
    else
354
0
    {
355
0
        nSizeRet = ser_readdata64(is);
356
0
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
0
    }
359
1.03k
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
1.03k
    return nSizeRet;
363
1.03k
}
unsigned long ReadCompactSize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, bool)
Line
Count
Source
334
6
{
335
6
    uint8_t chSize = ser_readdata8(is);
336
6
    uint64_t nSizeRet = 0;
337
6
    if (chSize < 253)
338
6
    {
339
6
        nSizeRet = chSize;
340
6
    }
341
0
    else if (chSize == 253)
342
0
    {
343
0
        nSizeRet = ser_readdata16(is);
344
0
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
0
    }
347
0
    else if (chSize == 254)
348
0
    {
349
0
        nSizeRet = ser_readdata32(is);
350
0
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
0
    }
353
0
    else
354
0
    {
355
0
        nSizeRet = ser_readdata64(is);
356
0
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
0
    }
359
6
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
6
    return nSizeRet;
363
6
}
unsigned long ReadCompactSize<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&, bool)
Line
Count
Source
334
3
{
335
3
    uint8_t chSize = ser_readdata8(is);
336
3
    uint64_t nSizeRet = 0;
337
3
    if (chSize < 253)
338
3
    {
339
3
        nSizeRet = chSize;
340
3
    }
341
0
    else if (chSize == 253)
342
0
    {
343
0
        nSizeRet = ser_readdata16(is);
344
0
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
0
    }
347
0
    else if (chSize == 254)
348
0
    {
349
0
        nSizeRet = ser_readdata32(is);
350
0
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
0
    }
353
0
    else
354
0
    {
355
0
        nSizeRet = ser_readdata64(is);
356
0
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
0
    }
359
3
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
3
    return nSizeRet;
363
3
}
unsigned long ReadCompactSize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&, bool)
Line
Count
Source
334
4.17k
{
335
4.17k
    uint8_t chSize = ser_readdata8(is);
336
4.17k
    uint64_t nSizeRet = 0;
337
4.17k
    if (chSize < 253)
338
4.03k
    {
339
4.03k
        nSizeRet = chSize;
340
4.03k
    }
341
135
    else if (chSize == 253)
342
13
    {
343
13
        nSizeRet = ser_readdata16(is);
344
13
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
13
    }
347
122
    else if (chSize == 254)
348
122
    {
349
122
        nSizeRet = ser_readdata32(is);
350
122
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
122
    }
353
0
    else
354
0
    {
355
0
        nSizeRet = ser_readdata64(is);
356
0
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
0
    }
359
4.17k
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
4.17k
    return nSizeRet;
363
4.17k
}
Unexecuted instantiation: unsigned long ReadCompactSize<ParamsStream<SpanReader, CAddress::SerParams>>(ParamsStream<SpanReader, CAddress::SerParams>&, bool)
Unexecuted instantiation: unsigned long ReadCompactSize<ParamsStream<DataStream&, CNetAddr::SerParams>>(ParamsStream<DataStream&, CNetAddr::SerParams>&, bool)
unsigned long ReadCompactSize<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&, bool)
Line
Count
Source
334
54.7k
{
335
54.7k
    uint8_t chSize = ser_readdata8(is);
336
54.7k
    uint64_t nSizeRet = 0;
337
54.7k
    if (chSize < 253)
338
54.7k
    {
339
54.7k
        nSizeRet = chSize;
340
54.7k
    }
341
6
    else if (chSize == 253)
342
5
    {
343
5
        nSizeRet = ser_readdata16(is);
344
5
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
5
    }
347
1
    else if (chSize == 254)
348
0
    {
349
0
        nSizeRet = ser_readdata32(is);
350
0
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
0
    }
353
1
    else
354
1
    {
355
1
        nSizeRet = ser_readdata64(is);
356
1
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
1
    }
359
54.7k
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
54.7k
    return nSizeRet;
363
54.7k
}
unsigned long ReadCompactSize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&, bool)
Line
Count
Source
334
17.9k
{
335
17.9k
    uint8_t chSize = ser_readdata8(is);
336
17.9k
    uint64_t nSizeRet = 0;
337
17.9k
    if (chSize < 253)
338
17.9k
    {
339
17.9k
        nSizeRet = chSize;
340
17.9k
    }
341
0
    else if (chSize == 253)
342
0
    {
343
0
        nSizeRet = ser_readdata16(is);
344
0
        if (nSizeRet < 253)
345
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
346
0
    }
347
0
    else if (chSize == 254)
348
0
    {
349
0
        nSizeRet = ser_readdata32(is);
350
0
        if (nSizeRet < 0x10000u)
351
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
352
0
    }
353
0
    else
354
0
    {
355
0
        nSizeRet = ser_readdata64(is);
356
0
        if (nSizeRet < 0x100000000ULL)
357
0
            throw std::ios_base::failure("non-canonical ReadCompactSize()");
358
0
    }
359
17.9k
    if (range_check && nSizeRet > MAX_SIZE) {
360
0
        throw std::ios_base::failure("ReadCompactSize(): size too large");
361
0
    }
362
17.9k
    return nSizeRet;
363
17.9k
}
364
365
/**
366
 * Variable-length integers: bytes are a MSB base-128 encoding of the number.
367
 * The high bit in each byte signifies whether another digit follows. To make
368
 * sure the encoding is one-to-one, one is subtracted from all but the last digit.
369
 * Thus, the byte sequence a[] with length len, where all but the last byte
370
 * has bit 128 set, encodes the number:
371
 *
372
 *  (a[len-1] & 0x7F) + sum(i=1..len-1, 128^i*((a[len-i-1] & 0x7F)+1))
373
 *
374
 * Properties:
375
 * * Very small (0-127: 1 byte, 128-16511: 2 bytes, 16512-2113663: 3 bytes)
376
 * * Every integer has exactly one encoding
377
 * * Encoding does not depend on size of original integer type
378
 * * No redundancy: every (infinite) byte sequence corresponds to a list
379
 *   of encoded integers.
380
 *
381
 * 0:         [0x00]  256:        [0x81 0x00]
382
 * 1:         [0x01]  16383:      [0xFE 0x7F]
383
 * 127:       [0x7F]  16384:      [0xFF 0x00]
384
 * 128:  [0x80 0x00]  16511:      [0xFF 0x7F]
385
 * 255:  [0x80 0x7F]  65535: [0x82 0xFE 0x7F]
386
 * 2^32:           [0x8E 0xFE 0xFE 0xFF 0x00]
387
 */
388
389
/**
390
 * Mode for encoding VarInts.
391
 *
392
 * Currently there is no support for signed encodings. The default mode will not
393
 * compile with signed values, and the legacy "nonnegative signed" mode will
394
 * accept signed values, but improperly encode and decode them if they are
395
 * negative. In the future, the DEFAULT mode could be extended to support
396
 * negative numbers in a backwards compatible way, and additional modes could be
397
 * added to support different varint formats (e.g. zigzag encoding).
398
 */
399
enum class VarIntMode { DEFAULT, NONNEGATIVE_SIGNED };
400
401
template <VarIntMode Mode, typename I>
402
struct CheckVarIntMode {
403
    constexpr CheckVarIntMode()
404
11.3M
    {
405
11.3M
        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned_v<I>, "Unsigned type required with mode DEFAULT.");
406
11.3M
        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed_v<I>, "Signed type required with mode NONNEGATIVE_SIGNED.");
407
11.3M
    }
CheckVarIntMode<(VarIntMode)1, int>::CheckVarIntMode()
Line
Count
Source
404
1.20M
    {
405
1.20M
        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned_v<I>, "Unsigned type required with mode DEFAULT.");
406
1.20M
        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed_v<I>, "Signed type required with mode NONNEGATIVE_SIGNED.");
407
1.20M
    }
CheckVarIntMode<(VarIntMode)0, unsigned long>::CheckVarIntMode()
Line
Count
Source
404
1.41M
    {
405
1.41M
        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned_v<I>, "Unsigned type required with mode DEFAULT.");
406
1.41M
        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed_v<I>, "Signed type required with mode NONNEGATIVE_SIGNED.");
407
1.41M
    }
CheckVarIntMode<(VarIntMode)0, unsigned int>::CheckVarIntMode()
Line
Count
Source
404
8.70M
    {
405
8.70M
        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned_v<I>, "Unsigned type required with mode DEFAULT.");
406
8.70M
        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed_v<I>, "Signed type required with mode NONNEGATIVE_SIGNED.");
407
8.70M
    }
CheckVarIntMode<(VarIntMode)1, signed char>::CheckVarIntMode()
Line
Count
Source
404
1
    {
405
1
        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned_v<I>, "Unsigned type required with mode DEFAULT.");
406
1
        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed_v<I>, "Signed type required with mode NONNEGATIVE_SIGNED.");
407
1
    }
CheckVarIntMode<(VarIntMode)0, unsigned char>::CheckVarIntMode()
Line
Count
Source
404
1
    {
405
1
        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned_v<I>, "Unsigned type required with mode DEFAULT.");
406
1
        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed_v<I>, "Signed type required with mode NONNEGATIVE_SIGNED.");
407
1
    }
CheckVarIntMode<(VarIntMode)1, short>::CheckVarIntMode()
Line
Count
Source
404
1
    {
405
1
        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned_v<I>, "Unsigned type required with mode DEFAULT.");
406
1
        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed_v<I>, "Signed type required with mode NONNEGATIVE_SIGNED.");
407
1
    }
CheckVarIntMode<(VarIntMode)0, unsigned short>::CheckVarIntMode()
Line
Count
Source
404
1
    {
405
1
        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned_v<I>, "Unsigned type required with mode DEFAULT.");
406
1
        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed_v<I>, "Signed type required with mode NONNEGATIVE_SIGNED.");
407
1
    }
CheckVarIntMode<(VarIntMode)1, long long>::CheckVarIntMode()
Line
Count
Source
404
1
    {
405
1
        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned_v<I>, "Unsigned type required with mode DEFAULT.");
406
1
        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed_v<I>, "Signed type required with mode NONNEGATIVE_SIGNED.");
407
1
    }
CheckVarIntMode<(VarIntMode)0, unsigned long long>::CheckVarIntMode()
Line
Count
Source
404
1
    {
405
1
        static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned_v<I>, "Unsigned type required with mode DEFAULT.");
406
1
        static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed_v<I>, "Signed type required with mode NONNEGATIVE_SIGNED.");
407
1
    }
408
};
409
410
template<VarIntMode Mode, typename I>
411
inline unsigned int GetSizeOfVarInt(I n)
412
{
413
    CheckVarIntMode<Mode, I>();
414
    int nRet = 0;
415
    while(true) {
416
        nRet++;
417
        if (n <= 0x7F)
418
            break;
419
        n = (n >> 7) - 1;
420
    }
421
    return nRet;
422
}
423
424
template<typename I>
425
inline void WriteVarInt(SizeComputer& os, I n);
426
427
template<typename Stream, VarIntMode Mode, typename I>
428
void WriteVarInt(Stream& os, I n)
429
8.16M
{
430
8.16M
    CheckVarIntMode<Mode, I>();
431
8.16M
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
8.16M
    int len=0;
433
19.4M
    while(true) {
434
19.4M
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
19.4M
        if (n <= 0x7F)
436
8.16M
            break;
437
11.2M
        n = (n >> 7) - 1;
438
11.2M
        len++;
439
11.2M
    }
440
19.4M
    do {
441
19.4M
        ser_writedata8(os, tmp[len]);
442
19.4M
    } while(len--);
443
8.16M
}
void WriteVarInt<VectorWriter, (VarIntMode)1, int>(VectorWriter&, int)
Line
Count
Source
429
25.0k
{
430
25.0k
    CheckVarIntMode<Mode, I>();
431
25.0k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
25.0k
    int len=0;
433
50.3k
    while(true) {
434
50.3k
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
50.3k
        if (n <= 0x7F)
436
25.0k
            break;
437
25.3k
        n = (n >> 7) - 1;
438
25.3k
        len++;
439
25.3k
    }
440
50.3k
    do {
441
50.3k
        ser_writedata8(os, tmp[len]);
442
50.3k
    } while(len--);
443
25.0k
}
void WriteVarInt<VectorWriter, (VarIntMode)0, unsigned long>(VectorWriter&, unsigned long)
Line
Count
Source
429
124k
{
430
124k
    CheckVarIntMode<Mode, I>();
431
124k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
124k
    int len=0;
433
156k
    while(true) {
434
156k
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
156k
        if (n <= 0x7F)
436
124k
            break;
437
31.2k
        n = (n >> 7) - 1;
438
31.2k
        len++;
439
31.2k
    }
440
156k
    do {
441
156k
        ser_writedata8(os, tmp[len]);
442
156k
    } while(len--);
443
124k
}
void WriteVarInt<DataStream, (VarIntMode)0, unsigned long>(DataStream&, unsigned long)
Line
Count
Source
429
293k
{
430
293k
    CheckVarIntMode<Mode, I>();
431
293k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
293k
    int len=0;
433
1.03M
    while(true) {
434
1.03M
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
1.03M
        if (n <= 0x7F)
436
293k
            break;
437
742k
        n = (n >> 7) - 1;
438
742k
        len++;
439
742k
    }
440
1.03M
    do {
441
1.03M
        ser_writedata8(os, tmp[len]);
442
1.03M
    } while(len--);
443
293k
}
void WriteVarInt<DataStream, (VarIntMode)1, int>(DataStream&, int)
Line
Count
Source
429
443k
{
430
443k
    CheckVarIntMode<Mode, I>();
431
443k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
443k
    int len=0;
433
954k
    while(true) {
434
954k
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
954k
        if (n <= 0x7F)
436
443k
            break;
437
510k
        n = (n >> 7) - 1;
438
510k
        len++;
439
510k
    }
440
954k
    do {
441
954k
        ser_writedata8(os, tmp[len]);
442
954k
    } while(len--);
443
443k
}
void WriteVarInt<SizeComputer, (VarIntMode)1, int>(SizeComputer&, int)
Line
Count
Source
429
100k
{
430
100k
    CheckVarIntMode<Mode, I>();
431
100k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
100k
    int len=0;
433
283k
    while(true) {
434
283k
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
283k
        if (n <= 0x7F)
436
100k
            break;
437
183k
        n = (n >> 7) - 1;
438
183k
        len++;
439
183k
    }
440
283k
    do {
441
283k
        ser_writedata8(os, tmp[len]);
442
283k
    } while(len--);
443
100k
}
void WriteVarInt<SizeComputer, (VarIntMode)0, unsigned long>(SizeComputer&, unsigned long)
Line
Count
Source
429
69.6k
{
430
69.6k
    CheckVarIntMode<Mode, I>();
431
69.6k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
69.6k
    int len=0;
433
240k
    while(true) {
434
240k
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
240k
        if (n <= 0x7F)
436
69.6k
            break;
437
170k
        n = (n >> 7) - 1;
438
170k
        len++;
439
170k
    }
440
240k
    do {
441
240k
        ser_writedata8(os, tmp[len]);
442
240k
    } while(len--);
443
69.6k
}
void WriteVarInt<DataStream, (VarIntMode)1, signed char>(DataStream&, signed char)
Line
Count
Source
429
1
{
430
1
    CheckVarIntMode<Mode, I>();
431
1
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
1
    int len=0;
433
1
    while(true) {
434
1
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
1
        if (n <= 0x7F)
436
1
            break;
437
0
        n = (n >> 7) - 1;
438
0
        len++;
439
0
    }
440
1
    do {
441
1
        ser_writedata8(os, tmp[len]);
442
1
    } while(len--);
443
1
}
void WriteVarInt<DataStream, (VarIntMode)0, unsigned char>(DataStream&, unsigned char)
Line
Count
Source
429
1
{
430
1
    CheckVarIntMode<Mode, I>();
431
1
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
1
    int len=0;
433
2
    while(true) {
434
2
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
2
        if (n <= 0x7F)
436
1
            break;
437
1
        n = (n >> 7) - 1;
438
1
        len++;
439
1
    }
440
2
    do {
441
2
        ser_writedata8(os, tmp[len]);
442
2
    } while(len--);
443
1
}
void WriteVarInt<DataStream, (VarIntMode)1, short>(DataStream&, short)
Line
Count
Source
429
1
{
430
1
    CheckVarIntMode<Mode, I>();
431
1
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
1
    int len=0;
433
2
    while(true) {
434
2
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
2
        if (n <= 0x7F)
436
1
            break;
437
1
        n = (n >> 7) - 1;
438
1
        len++;
439
1
    }
440
2
    do {
441
2
        ser_writedata8(os, tmp[len]);
442
2
    } while(len--);
443
1
}
void WriteVarInt<DataStream, (VarIntMode)0, unsigned short>(DataStream&, unsigned short)
Line
Count
Source
429
1
{
430
1
    CheckVarIntMode<Mode, I>();
431
1
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
1
    int len=0;
433
3
    while(true) {
434
3
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
3
        if (n <= 0x7F)
436
1
            break;
437
2
        n = (n >> 7) - 1;
438
2
        len++;
439
2
    }
440
3
    do {
441
3
        ser_writedata8(os, tmp[len]);
442
3
    } while(len--);
443
1
}
void WriteVarInt<DataStream, (VarIntMode)0, unsigned int>(DataStream&, unsigned int)
Line
Count
Source
429
6.56M
{
430
6.56M
    CheckVarIntMode<Mode, I>();
431
6.56M
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
6.56M
    int len=0;
433
15.6M
    while(true) {
434
15.6M
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
15.6M
        if (n <= 0x7F)
436
6.56M
            break;
437
9.08M
        n = (n >> 7) - 1;
438
9.08M
        len++;
439
9.08M
    }
440
15.6M
    do {
441
15.6M
        ser_writedata8(os, tmp[len]);
442
15.6M
    } while(len--);
443
6.56M
}
void WriteVarInt<DataStream, (VarIntMode)1, long long>(DataStream&, long long)
Line
Count
Source
429
1
{
430
1
    CheckVarIntMode<Mode, I>();
431
1
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
1
    int len=0;
433
9
    while(true) {
434
9
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
9
        if (n <= 0x7F)
436
1
            break;
437
8
        n = (n >> 7) - 1;
438
8
        len++;
439
8
    }
440
9
    do {
441
9
        ser_writedata8(os, tmp[len]);
442
9
    } while(len--);
443
1
}
void WriteVarInt<DataStream, (VarIntMode)0, unsigned long long>(DataStream&, unsigned long long)
Line
Count
Source
429
1
{
430
1
    CheckVarIntMode<Mode, I>();
431
1
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
1
    int len=0;
433
10
    while(true) {
434
10
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
10
        if (n <= 0x7F)
436
1
            break;
437
9
        n = (n >> 7) - 1;
438
9
        len++;
439
9
    }
440
10
    do {
441
10
        ser_writedata8(os, tmp[len]);
442
10
    } while(len--);
443
1
}
void WriteVarInt<SizeComputer, (VarIntMode)0, unsigned int>(SizeComputer&, unsigned int)
Line
Count
Source
429
129k
{
430
129k
    CheckVarIntMode<Mode, I>();
431
129k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
129k
    int len=0;
433
196k
    while(true) {
434
196k
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
196k
        if (n <= 0x7F)
436
129k
            break;
437
66.9k
        n = (n >> 7) - 1;
438
66.9k
        len++;
439
66.9k
    }
440
196k
    do {
441
196k
        ser_writedata8(os, tmp[len]);
442
196k
    } while(len--);
443
129k
}
void WriteVarInt<HashWriter, (VarIntMode)0, unsigned int>(HashWriter&, unsigned int)
Line
Count
Source
429
129k
{
430
129k
    CheckVarIntMode<Mode, I>();
431
129k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
129k
    int len=0;
433
196k
    while(true) {
434
196k
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
196k
        if (n <= 0x7F)
436
129k
            break;
437
66.9k
        n = (n >> 7) - 1;
438
66.9k
        len++;
439
66.9k
    }
440
196k
    do {
441
196k
        ser_writedata8(os, tmp[len]);
442
196k
    } while(len--);
443
129k
}
void WriteVarInt<HashWriter, (VarIntMode)0, unsigned long>(HashWriter&, unsigned long)
Line
Count
Source
429
69.5k
{
430
69.5k
    CheckVarIntMode<Mode, I>();
431
69.5k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
69.5k
    int len=0;
433
239k
    while(true) {
434
239k
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
239k
        if (n <= 0x7F)
436
69.5k
            break;
437
169k
        n = (n >> 7) - 1;
438
169k
        len++;
439
169k
    }
440
239k
    do {
441
239k
        ser_writedata8(os, tmp[len]);
442
239k
    } while(len--);
443
69.5k
}
void WriteVarInt<BufferedWriter<AutoFile>, (VarIntMode)0, unsigned int>(BufferedWriter<AutoFile>&, unsigned int)
Line
Count
Source
429
129k
{
430
129k
    CheckVarIntMode<Mode, I>();
431
129k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
129k
    int len=0;
433
196k
    while(true) {
434
196k
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
196k
        if (n <= 0x7F)
436
129k
            break;
437
66.9k
        n = (n >> 7) - 1;
438
66.9k
        len++;
439
66.9k
    }
440
196k
    do {
441
196k
        ser_writedata8(os, tmp[len]);
442
196k
    } while(len--);
443
129k
}
void WriteVarInt<BufferedWriter<AutoFile>, (VarIntMode)0, unsigned long>(BufferedWriter<AutoFile>&, unsigned long)
Line
Count
Source
429
69.5k
{
430
69.5k
    CheckVarIntMode<Mode, I>();
431
69.5k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
69.5k
    int len=0;
433
239k
    while(true) {
434
239k
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
239k
        if (n <= 0x7F)
436
69.5k
            break;
437
169k
        n = (n >> 7) - 1;
438
169k
        len++;
439
169k
    }
440
239k
    do {
441
239k
        ser_writedata8(os, tmp[len]);
442
239k
    } while(len--);
443
69.5k
}
void WriteVarInt<AutoFile, (VarIntMode)0, unsigned int>(AutoFile&, unsigned int)
Line
Count
Source
429
7.05k
{
430
7.05k
    CheckVarIntMode<Mode, I>();
431
7.05k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
7.05k
    int len=0;
433
10.8k
    while(true) {
434
10.8k
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
10.8k
        if (n <= 0x7F)
436
7.05k
            break;
437
3.83k
        n = (n >> 7) - 1;
438
3.83k
        len++;
439
3.83k
    }
440
10.8k
    do {
441
10.8k
        ser_writedata8(os, tmp[len]);
442
10.8k
    } while(len--);
443
7.05k
}
void WriteVarInt<AutoFile, (VarIntMode)0, unsigned long>(AutoFile&, unsigned long)
Line
Count
Source
429
6.58k
{
430
6.58k
    CheckVarIntMode<Mode, I>();
431
6.58k
    unsigned char tmp[CeilDiv(sizeof(n) * 8, 7u)];
432
6.58k
    int len=0;
433
8.98k
    while(true) {
434
8.98k
        tmp[len] = (n & 0x7F) | (len ? 0x80 : 0x00);
435
8.98k
        if (n <= 0x7F)
436
6.58k
            break;
437
2.40k
        n = (n >> 7) - 1;
438
2.40k
        len++;
439
2.40k
    }
440
8.98k
    do {
441
8.98k
        ser_writedata8(os, tmp[len]);
442
8.98k
    } while(len--);
443
6.58k
}
444
445
template<typename Stream, VarIntMode Mode, typename I>
446
I ReadVarInt(Stream& is)
447
3.15M
{
448
3.15M
    CheckVarIntMode<Mode, I>();
449
3.15M
    I n = 0;
450
5.51M
    while(true) {
451
5.51M
        unsigned char chData = ser_readdata8(is);
452
5.51M
        if (n > (std::numeric_limits<I>::max() >> 7)) {
453
0
           throw std::ios_base::failure("ReadVarInt(): size too large");
454
0
        }
455
5.51M
        n = (n << 7) | (chData & 0x7F);
456
5.51M
        if (chData & 0x80) {
457
2.35M
            if (n == std::numeric_limits<I>::max()) {
458
0
                throw std::ios_base::failure("ReadVarInt(): size too large");
459
0
            }
460
2.35M
            n++;
461
3.15M
        } else {
462
3.15M
            return n;
463
3.15M
        }
464
5.51M
    }
465
3.15M
}
int ReadVarInt<SpanReader, (VarIntMode)1, int>(SpanReader&)
Line
Count
Source
447
79.0k
{
448
79.0k
    CheckVarIntMode<Mode, I>();
449
79.0k
    I n = 0;
450
154k
    while(true) {
451
154k
        unsigned char chData = ser_readdata8(is);
452
154k
        if (n > (std::numeric_limits<I>::max() >> 7)) {
453
0
           throw std::ios_base::failure("ReadVarInt(): size too large");
454
0
        }
455
154k
        n = (n << 7) | (chData & 0x7F);
456
154k
        if (chData & 0x80) {
457
75.9k
            if (n == std::numeric_limits<I>::max()) {
458
0
                throw std::ios_base::failure("ReadVarInt(): size too large");
459
0
            }
460
75.9k
            n++;
461
79.0k
        } else {
462
79.0k
            return n;
463
79.0k
        }
464
154k
    }
465
79.0k
}
unsigned long ReadVarInt<SpanReader, (VarIntMode)0, unsigned long>(SpanReader&)
Line
Count
Source
447
466k
{
448
466k
    CheckVarIntMode<Mode, I>();
449
466k
    I n = 0;
450
1.02M
    while(true) {
451
1.02M
        unsigned char chData = ser_readdata8(is);
452
1.02M
        if (n > (std::numeric_limits<I>::max() >> 7)) {
453
0
           throw std::ios_base::failure("ReadVarInt(): size too large");
454
0
        }
455
1.02M
        n = (n << 7) | (chData & 0x7F);
456
1.02M
        if (chData & 0x80) {
457
557k
            if (n == std::numeric_limits<I>::max()) {
458
0
                throw std::ios_base::failure("ReadVarInt(): size too large");
459
0
            }
460
557k
            n++;
461
557k
        } else {
462
466k
            return n;
463
466k
        }
464
1.02M
    }
465
466k
}
unsigned int ReadVarInt<SpanReader, (VarIntMode)0, unsigned int>(SpanReader&)
Line
Count
Source
447
464k
{
448
464k
    CheckVarIntMode<Mode, I>();
449
464k
    I n = 0;
450
498k
    while(true) {
451
498k
        unsigned char chData = ser_readdata8(is);
452
498k
        if (n > (std::numeric_limits<I>::max() >> 7)) {
453
0
           throw std::ios_base::failure("ReadVarInt(): size too large");
454
0
        }
455
498k
        n = (n << 7) | (chData & 0x7F);
456
498k
        if (chData & 0x80) {
457
34.4k
            if (n == std::numeric_limits<I>::max()) {
458
0
                throw std::ios_base::failure("ReadVarInt(): size too large");
459
0
            }
460
34.4k
            n++;
461
464k
        } else {
462
464k
            return n;
463
464k
        }
464
498k
    }
465
464k
}
int ReadVarInt<DataStream, (VarIntMode)1, int>(DataStream&)
Line
Count
Source
447
558k
{
448
558k
    CheckVarIntMode<Mode, I>();
449
558k
    I n = 0;
450
1.11M
    while(true) {
451
1.11M
        unsigned char chData = ser_readdata8(is);
452
1.11M
        if (n > (std::numeric_limits<I>::max() >> 7)) {
453
0
           throw std::ios_base::failure("ReadVarInt(): size too large");
454
0
        }
455
1.11M
        n = (n << 7) | (chData & 0x7F);
456
1.11M
        if (chData & 0x80) {
457
556k
            if (n == std::numeric_limits<I>::max()) {
458
0
                throw std::ios_base::failure("ReadVarInt(): size too large");
459
0
            }
460
556k
            n++;
461
558k
        } else {
462
558k
            return n;
463
558k
        }
464
1.11M
    }
465
558k
}
unsigned long ReadVarInt<DataStream, (VarIntMode)0, unsigned long>(DataStream&)
Line
Count
Source
447
279k
{
448
279k
    CheckVarIntMode<Mode, I>();
449
279k
    I n = 0;
450
540k
    while(true) {
451
540k
        unsigned char chData = ser_readdata8(is);
452
540k
        if (n > (std::numeric_limits<I>::max() >> 7)) {
453
0
           throw std::ios_base::failure("ReadVarInt(): size too large");
454
0
        }
455
540k
        n = (n << 7) | (chData & 0x7F);
456
540k
        if (chData & 0x80) {
457
261k
            if (n == std::numeric_limits<I>::max()) {
458
0
                throw std::ios_base::failure("ReadVarInt(): size too large");
459
0
            }
460
261k
            n++;
461
279k
        } else {
462
279k
            return n;
463
279k
        }
464
540k
    }
465
279k
}
unsigned int ReadVarInt<DataStream, (VarIntMode)0, unsigned int>(DataStream&)
Line
Count
Source
447
1.16M
{
448
1.16M
    CheckVarIntMode<Mode, I>();
449
1.16M
    I n = 0;
450
1.94M
    while(true) {
451
1.94M
        unsigned char chData = ser_readdata8(is);
452
1.94M
        if (n > (std::numeric_limits<I>::max() >> 7)) {
453
0
           throw std::ios_base::failure("ReadVarInt(): size too large");
454
0
        }
455
1.94M
        n = (n << 7) | (chData & 0x7F);
456
1.94M
        if (chData & 0x80) {
457
777k
            if (n == std::numeric_limits<I>::max()) {
458
0
                throw std::ios_base::failure("ReadVarInt(): size too large");
459
0
            }
460
777k
            n++;
461
1.16M
        } else {
462
1.16M
            return n;
463
1.16M
        }
464
1.94M
    }
465
1.16M
}
unsigned int ReadVarInt<AutoFile, (VarIntMode)0, unsigned int>(AutoFile&)
Line
Count
Source
447
12.7k
{
448
12.7k
    CheckVarIntMode<Mode, I>();
449
12.7k
    I n = 0;
450
17.0k
    while(true) {
451
17.0k
        unsigned char chData = ser_readdata8(is);
452
17.0k
        if (n > (std::numeric_limits<I>::max() >> 7)) {
453
0
           throw std::ios_base::failure("ReadVarInt(): size too large");
454
0
        }
455
17.0k
        n = (n << 7) | (chData & 0x7F);
456
17.0k
        if (chData & 0x80) {
457
4.33k
            if (n == std::numeric_limits<I>::max()) {
458
0
                throw std::ios_base::failure("ReadVarInt(): size too large");
459
0
            }
460
4.33k
            n++;
461
12.7k
        } else {
462
12.7k
            return n;
463
12.7k
        }
464
17.0k
    }
465
12.7k
}
unsigned long ReadVarInt<AutoFile, (VarIntMode)0, unsigned long>(AutoFile&)
Line
Count
Source
447
6.35k
{
448
6.35k
    CheckVarIntMode<Mode, I>();
449
6.35k
    I n = 0;
450
11.1k
    while(true) {
451
11.1k
        unsigned char chData = ser_readdata8(is);
452
11.1k
        if (n > (std::numeric_limits<I>::max() >> 7)) {
453
0
           throw std::ios_base::failure("ReadVarInt(): size too large");
454
0
        }
455
11.1k
        n = (n << 7) | (chData & 0x7F);
456
11.1k
        if (chData & 0x80) {
457
4.77k
            if (n == std::numeric_limits<I>::max()) {
458
0
                throw std::ios_base::failure("ReadVarInt(): size too large");
459
0
            }
460
4.77k
            n++;
461
6.35k
        } else {
462
6.35k
            return n;
463
6.35k
        }
464
11.1k
    }
465
6.35k
}
unsigned int ReadVarInt<HashVerifier<BufferedReader<AutoFile>>, (VarIntMode)0, unsigned int>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
447
93.4k
{
448
93.4k
    CheckVarIntMode<Mode, I>();
449
93.4k
    I n = 0;
450
123k
    while(true) {
451
123k
        unsigned char chData = ser_readdata8(is);
452
123k
        if (n > (std::numeric_limits<I>::max() >> 7)) {
453
0
           throw std::ios_base::failure("ReadVarInt(): size too large");
454
0
        }
455
123k
        n = (n << 7) | (chData & 0x7F);
456
123k
        if (chData & 0x80) {
457
30.2k
            if (n == std::numeric_limits<I>::max()) {
458
0
                throw std::ios_base::failure("ReadVarInt(): size too large");
459
0
            }
460
30.2k
            n++;
461
93.4k
        } else {
462
93.4k
            return n;
463
93.4k
        }
464
123k
    }
465
93.4k
}
unsigned long ReadVarInt<HashVerifier<BufferedReader<AutoFile>>, (VarIntMode)0, unsigned long>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
447
31.1k
{
448
31.1k
    CheckVarIntMode<Mode, I>();
449
31.1k
    I n = 0;
450
83.6k
    while(true) {
451
83.6k
        unsigned char chData = ser_readdata8(is);
452
83.6k
        if (n > (std::numeric_limits<I>::max() >> 7)) {
453
0
           throw std::ios_base::failure("ReadVarInt(): size too large");
454
0
        }
455
83.6k
        n = (n << 7) | (chData & 0x7F);
456
83.6k
        if (chData & 0x80) {
457
52.4k
            if (n == std::numeric_limits<I>::max()) {
458
0
                throw std::ios_base::failure("ReadVarInt(): size too large");
459
0
            }
460
52.4k
            n++;
461
52.4k
        } else {
462
31.1k
            return n;
463
31.1k
        }
464
83.6k
    }
465
31.1k
}
466
467
/** Simple wrapper class to serialize objects using a formatter; used by Using(). */
468
template<typename Formatter, typename T>
469
class Wrapper
470
{
471
    static_assert(std::is_lvalue_reference_v<T>, "Wrapper needs an lvalue reference type T");
472
protected:
473
    T m_object;
474
public:
475
34.8M
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>::Wrapper(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&)
Line
Count
Source
475
69.3k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CompactSizeFormatter<false>, unsigned long&>::Wrapper(unsigned long&)
Line
Count
Source
475
71.9k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>::Wrapper(ServiceFlags const&)
Line
Count
Source
475
18.9k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CompactSizeFormatter<true>, unsigned long const&>::Wrapper(unsigned long const&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CustomUintFormatter<2, true>, unsigned short const&>::Wrapper(unsigned short const&)
Line
Count
Source
475
72.8k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>::Wrapper(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&)
Line
Count
Source
475
50.3k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CustomUintFormatter<4, true>, unsigned int const&>::Wrapper(unsigned int const&)
Line
Count
Source
475
157k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CustomUintFormatter<4, true>, unsigned int&>::Wrapper(unsigned int&)
Line
Count
Source
475
15.3k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>::Wrapper(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
475
395k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>::Wrapper(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
475
650k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>::Wrapper(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
475
357k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CompactSizeFormatter<true>, unsigned short&>::Wrapper(unsigned short&)
Line
Count
Source
475
21.6k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>::Wrapper(std::shared_ptr<CTransaction const>&)
Line
Count
Source
475
21.6k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&>::Wrapper(std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&)
Line
Count
Source
475
21.6k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>>&>::Wrapper(std::vector<unsigned long, std::allocator<unsigned long>>&)
Line
Count
Source
475
21.6k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>::Wrapper(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
475
7.82M
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>::Wrapper(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
475
6.44M
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>::Wrapper(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
475
1.93M
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CompactSizeFormatter<true>, unsigned short const&>::Wrapper(unsigned short const&)
Line
Count
Source
475
54.5k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>::Wrapper(std::shared_ptr<CTransaction const> const&)
Line
Count
Source
475
54.5k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&>::Wrapper(std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
475
54.5k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>::Wrapper(std::vector<unsigned long, std::allocator<unsigned long>> const&)
Line
Count
Source
475
54.5k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&>::Wrapper(std::vector<unsigned short, std::allocator<unsigned short>> const&)
Line
Count
Source
475
579
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>>&>::Wrapper(std::vector<unsigned short, std::allocator<unsigned short>>&)
Line
Count
Source
475
597
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>::Wrapper(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
475
848k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>::Wrapper(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
475
176k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>::Wrapper(std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
475
32.9k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VarIntFormatter<(VarIntMode)1>, int&>::Wrapper(int&)
Line
Count
Source
475
955k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>::Wrapper(unsigned long&)
Line
Count
Source
475
1.41M
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>>&>::Wrapper(cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>>&)
Line
Count
Source
475
681
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VarIntFormatter<(VarIntMode)1>, int const&>::Wrapper(int const&)
Line
Count
Source
475
251k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>> const&>::Wrapper(cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>> const&)
Line
Count
Source
475
227
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>>&>::Wrapper(cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>>&)
Line
Count
Source
475
681
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>> const&>::Wrapper(cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>> const&)
Line
Count
Source
475
227
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>>&>::Wrapper(cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>>&)
Line
Count
Source
475
681
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>> const&>::Wrapper(cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>> const&)
Line
Count
Source
475
227
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>>&>::Wrapper(cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>>&)
Line
Count
Source
475
403
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>> const&>::Wrapper(cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>> const&)
Line
Count
Source
475
132
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>>&>::Wrapper(cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>>&)
Line
Count
Source
475
375
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>> const&>::Wrapper(cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>> const&)
Line
Count
Source
475
125
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>::Wrapper(unsigned int&)
Line
Count
Source
475
8.24M
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<AmountCompression, long&>::Wrapper(long&)
Line
Count
Source
475
406k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<ScriptCompression, CScript&>::Wrapper(CScript&)
Line
Count
Source
475
406k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<TxOutCompression, CTxOut&>::Wrapper(CTxOut&)
Line
Count
Source
475
406k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<LimitedStringFormatter<256ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>::Wrapper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
475
1.71k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CompactSizeFormatter<true>, unsigned long&>::Wrapper(unsigned long&)
Line
Count
Source
475
42.1k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>::Wrapper(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
475
27.4k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>::Wrapper(ServiceFlags&)
Line
Count
Source
475
7.62k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CustomUintFormatter<2, true>, unsigned short&>::Wrapper(unsigned short&)
Line
Count
Source
475
29.2k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&>::Wrapper(std::vector<CAddress, std::allocator<CAddress>>&)
Line
Count
Source
475
92
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&>::Wrapper(std::vector<CAddress, std::allocator<CAddress>> const&)
Line
Count
Source
475
175
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>::Wrapper(std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
475
16.9k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<int, std::allocator<int>> const&>::Wrapper(std::vector<int, std::allocator<int>> const&)
Line
Count
Source
475
265k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, prevector<8u, int, unsigned int, int> const&>::Wrapper(prevector<8u, int, unsigned int, int> const&)
Line
Count
Source
475
265k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<LimitedVectorFormatter<0ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>::Wrapper(std::vector<int, std::allocator<int>>&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<LimitedVectorFormatter<10ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>::Wrapper(std::vector<int, std::allocator<int>>&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<LimitedVectorFormatter<12ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>::Wrapper(std::vector<int, std::allocator<int>>&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<LimitedVectorFormatter<13ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>::Wrapper(std::vector<int, std::allocator<int>>&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<LimitedVectorFormatter<14ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>::Wrapper(std::vector<int, std::allocator<int>>&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<LimitedVectorFormatter<100ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>::Wrapper(std::vector<int, std::allocator<int>>&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VarIntFormatter<(VarIntMode)1>, signed char&>::Wrapper(signed char&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned char&>::Wrapper(unsigned char&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VarIntFormatter<(VarIntMode)1>, short&>::Wrapper(short&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned short&>::Wrapper(unsigned short&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VarIntFormatter<(VarIntMode)1>, long long&>::Wrapper(long long&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long long&>::Wrapper(unsigned long long&)
Line
Count
Source
475
1
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>> const&>::Wrapper(std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>> const&)
Line
Count
Source
475
2
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>&>::Wrapper(std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>&)
Line
Count
Source
475
2
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CustomUintFormatter<3, true>, unsigned int&>::Wrapper(unsigned int&)
Line
Count
Source
475
330
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CustomUintFormatter<5, true>, unsigned long&>::Wrapper(unsigned long&)
Line
Count
Source
475
326
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&>::Wrapper(unsigned int const&)
Line
Count
Source
475
456k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CustomUintFormatter<3, true>, unsigned int const&>::Wrapper(unsigned int const&)
Line
Count
Source
475
4.58k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CustomUintFormatter<5, true>, unsigned long const&>::Wrapper(unsigned long const&)
Line
Count
Source
475
4.57k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&>::Wrapper(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
Line
Count
Source
475
24.7k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&>::Wrapper(std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&)
Line
Count
Source
475
11.4k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&>::Wrapper(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
Line
Count
Source
475
11.4k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&>::Wrapper(AddrManImpl::Format&)
Line
Count
Source
475
648
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>::Wrapper(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
475
20.5k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CInv, std::allocator<CInv>> const&>::Wrapper(std::vector<CInv, std::allocator<CInv>> const&)
Line
Count
Source
475
58.7k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<LimitedStringFormatter<80ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>::Wrapper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
475
56
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<LimitedVectorFormatter<512ul, DefaultFormatter>, std::vector<unsigned char, std::allocator<unsigned char>>&>::Wrapper(std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
475
52
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CInv, std::allocator<CInv>>&>::Wrapper(std::vector<CInv, std::allocator<CInv>>&)
Line
Count
Source
475
39.1k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CBlockHeader, std::allocator<CBlockHeader>> const&>::Wrapper(std::vector<CBlockHeader, std::allocator<CBlockHeader>> const&)
Line
Count
Source
475
9
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CBlock, std::allocator<CBlock>> const&>::Wrapper(std::vector<CBlock, std::allocator<CBlock>> const&)
Line
Count
Source
475
5.27k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long const&>::Wrapper(unsigned long const&)
Line
Count
Source
475
3.44k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>>&>::Wrapper(std::vector<Coin, std::allocator<Coin>>&)
Line
Count
Source
475
21.0k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>>&>::Wrapper(std::vector<CTxUndo, std::allocator<CTxUndo>>&)
Line
Count
Source
475
33.7k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<AmountCompression, long const&>::Wrapper(long const&)
Line
Count
Source
475
505k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<ScriptCompression, CScript const&>::Wrapper(CScript const&)
Line
Count
Source
475
505k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<TxOutCompression, CTxOut const&>::Wrapper(CTxOut const&)
Line
Count
Source
475
505k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>::Wrapper(std::vector<Coin, std::allocator<Coin>> const&)
Line
Count
Source
475
135k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>> const&>::Wrapper(std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
475
302k
    explicit Wrapper(T obj) : m_object(obj) {}
block_policy_estimator.cpp:Wrapper<(anonymous namespace)::EncodedDoubleFormatter, double const&>::Wrapper(double const&)
Line
Count
Source
475
3.34k
    explicit Wrapper(T obj) : m_object(obj) {}
block_policy_estimator.cpp:Wrapper<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>, std::vector<double, std::allocator<double>> const&>::Wrapper(std::vector<double, std::allocator<double>> const&)
Line
Count
Source
475
7.80k
    explicit Wrapper(T obj) : m_object(obj) {}
block_policy_estimator.cpp:Wrapper<VectorFormatter<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&>::Wrapper(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&)
Line
Count
Source
475
6.69k
    explicit Wrapper(T obj) : m_object(obj) {}
block_policy_estimator.cpp:Wrapper<(anonymous namespace)::EncodedDoubleFormatter, double&>::Wrapper(double&)
Line
Count
Source
475
1.74k
    explicit Wrapper(T obj) : m_object(obj) {}
block_policy_estimator.cpp:Wrapper<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>, std::vector<double, std::allocator<double>>&>::Wrapper(std::vector<double, std::allocator<double>>&)
Line
Count
Source
475
4.07k
    explicit Wrapper(T obj) : m_object(obj) {}
block_policy_estimator.cpp:Wrapper<VectorFormatter<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&>::Wrapper(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
Line
Count
Source
475
3.49k
    explicit Wrapper(T obj) : m_object(obj) {}
mempool_estimator.cpp:Wrapper<VectorFormatter<(anonymous namespace)::MinedBlockStatsFormatter>, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>>&>::Wrapper(std::vector<MinedBlockStats, std::allocator<MinedBlockStats>>&)
Line
Count
Source
475
587
    explicit Wrapper(T obj) : m_object(obj) {}
mempool_estimator.cpp:Wrapper<VectorFormatter<(anonymous namespace)::MinedBlockStatsFormatter>, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>> const&>::Wrapper(std::vector<MinedBlockStats, std::allocator<MinedBlockStats>> const&)
Line
Count
Source
475
1.11k
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<COutPoint, std::allocator<COutPoint>>&>::Wrapper(std::vector<COutPoint, std::allocator<COutPoint>>&)
Line
Count
Source
475
2
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CCoin, std::allocator<CCoin>> const&>::Wrapper(std::vector<CCoin, std::allocator<CCoin>> const&)
Line
Count
Source
475
3
    explicit Wrapper(T obj) : m_object(obj) {}
Wrapper<VectorFormatter<DefaultFormatter>, std::vector<unsigned int, std::allocator<unsigned int>>&>::Wrapper(std::vector<unsigned int, std::allocator<unsigned int>>&)
Line
Count
Source
475
277
    explicit Wrapper(T obj) : m_object(obj) {}
Unexecuted instantiation: Wrapper<VectorFormatter<DefaultFormatter>, std::vector<unsigned int, std::allocator<unsigned int>> const&>::Wrapper(std::vector<unsigned int, std::allocator<unsigned int>> const&)
476
28.4M
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>::Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&) const
Line
Count
Source
476
4.44M
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>::Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&) const
Line
Count
Source
476
3.71M
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>::Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&) const
Line
Count
Source
476
954k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>::Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&) const
Line
Count
Source
476
710k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
116k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>::Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&) const
Line
Count
Source
476
23
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CompactSizeFormatter<false>, unsigned long&>::Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&) const
Line
Count
Source
476
18
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>::Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&) const
Line
Count
Source
476
5
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
Unexecuted instantiation: void Wrapper<CompactSizeFormatter<true>, unsigned long const&>::Serialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&) const
void Wrapper<CustomUintFormatter<2, true>, unsigned short const&>::Serialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&) const
Line
Count
Source
476
23
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CompactSizeFormatter<true>, unsigned long const&>::Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&) const
Line
Count
Source
476
1
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>::Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&) const
Line
Count
Source
476
17
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CustomUintFormatter<4, true>, unsigned int const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
40
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
9
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
9
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CompactSizeFormatter<true>, unsigned short const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
11
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>::Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&) const
Line
Count
Source
476
11
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>::Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&) const
Line
Count
Source
476
196k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>::Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&) const
Line
Count
Source
476
101k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>::Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&) const
Line
Count
Source
476
116k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
2
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
29.9k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>> const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
227
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)1>, int const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
25.0k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
124k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>> const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
227
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>> const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
227
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>> const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
132
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>> const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
125
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>>&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
7
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
289k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>::Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&) const
Line
Count
Source
476
92.2k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>::Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&) const
Line
Count
Source
476
59.3k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>::Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&) const
Line
Count
Source
476
42.0k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<LimitedStringFormatter<256ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>::Serialize<AutoFile>(AutoFile&) const
Line
Count
Source
476
3
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>::Serialize<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&) const
Line
Count
Source
476
2.81M
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>::Serialize<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&) const
Line
Count
Source
476
2.41M
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>::Serialize<ParamsStream<HashWriter&, TransactionSerParams>>(ParamsStream<HashWriter&, TransactionSerParams>&) const
Line
Count
Source
476
556k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
Unexecuted instantiation: void Wrapper<CompactSizeFormatter<true>, unsigned long const&>::Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&) const
void Wrapper<CustomUintFormatter<2, true>, unsigned short const&>::Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&) const
Line
Count
Source
476
1
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&>::Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&) const
Line
Count
Source
476
2
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<int, std::allocator<int>> const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
265k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, prevector<8u, int, unsigned int, int> const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
265k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)1>, int&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
217k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)1>, int&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
100k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
69.6k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)1>, signed char&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
1
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned char&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
1
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)1>, short&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
1
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned short&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
1
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
6.11M
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)1>, long long&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
1
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long long&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
1
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>> const&>::Serialize<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&) const
Line
Count
Source
476
2
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
456k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CustomUintFormatter<3, true>, unsigned int const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
4.58k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CustomUintFormatter<5, true>, unsigned long const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
4.57k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)1>, int const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
226k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CustomUintFormatter<4, true>, unsigned int const&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
4
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
270
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
24.7k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
5
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
Unexecuted instantiation: void Wrapper<CompactSizeFormatter<true>, unsigned long const&>::Serialize<ParamsStream<VectorWriter&, CNetAddr::SerParams>>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&) const
void Wrapper<CustomUintFormatter<2, true>, unsigned short const&>::Serialize<ParamsStream<VectorWriter&, CNetAddr::SerParams>>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&) const
Line
Count
Source
476
3.48k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&>::Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&) const
Line
Count
Source
476
39
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>::Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&) const
Line
Count
Source
476
50.3k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CompactSizeFormatter<false>, unsigned long&>::Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&) const
Line
Count
Source
476
50.3k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
Unexecuted instantiation: void Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>::Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&) const
Unexecuted instantiation: void Wrapper<CompactSizeFormatter<true>, unsigned long const&>::Serialize<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&) const
void Wrapper<CustomUintFormatter<2, true>, unsigned short const&>::Serialize<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&) const
Line
Count
Source
476
50.3k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
Unexecuted instantiation: void Wrapper<CompactSizeFormatter<true>, unsigned long const&>::Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&) const
void Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>::Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&) const
Line
Count
Source
476
50.3k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
35.6k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
35.6k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CompactSizeFormatter<true>, unsigned short const&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
35.7k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>::Serialize<ParamsStream<SizeComputer&, TransactionSerParams>>(ParamsStream<SizeComputer&, TransactionSerParams>&) const
Line
Count
Source
476
35.7k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
18.8k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
18.8k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CompactSizeFormatter<true>, unsigned short const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
18.8k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>::Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&) const
Line
Count
Source
476
18.8k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CInv, std::allocator<CInv>> const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
58.7k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>::Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&) const
Line
Count
Source
476
35.6k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
3.01k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CBlockHeader, std::allocator<CBlockHeader>> const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
9
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CBlock, std::allocator<CBlock>> const&>::Serialize<ParamsStream<VectorWriter&, TransactionSerParams>>(ParamsStream<VectorWriter&, TransactionSerParams>&) const
Line
Count
Source
476
5.27k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
577
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&>::Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&) const
Line
Count
Source
476
134
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>::Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&) const
Line
Count
Source
476
18.9k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CompactSizeFormatter<false>, unsigned long&>::Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&) const
Line
Count
Source
476
33
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>::Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&) const
Line
Count
Source
476
18.9k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
Unexecuted instantiation: void Wrapper<CompactSizeFormatter<true>, unsigned long const&>::Serialize<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&) const
void Wrapper<CustomUintFormatter<2, true>, unsigned short const&>::Serialize<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&) const
Line
Count
Source
476
18.9k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
3.44k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>> const&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
100k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
45.0k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
129k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<TxOutCompression, CTxOut const&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
69.5k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<AmountCompression, long const&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
69.5k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<ScriptCompression, CScript const&>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
476
69.5k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>> const&>::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
476
100k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
476
45.0k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
476
129k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<TxOutCompression, CTxOut const&>::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
476
69.5k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<AmountCompression, long const&>::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
476
69.5k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
476
69.5k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<ScriptCompression, CScript const&>::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
476
69.5k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>> const&>::Serialize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&) const
Line
Count
Source
476
100k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>::Serialize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&) const
Line
Count
Source
476
45.0k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>::Serialize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&) const
Line
Count
Source
476
129k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<TxOutCompression, CTxOut const&>::Serialize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&) const
Line
Count
Source
476
69.5k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<AmountCompression, long const&>::Serialize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&) const
Line
Count
Source
476
69.5k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>::Serialize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&) const
Line
Count
Source
476
69.5k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<ScriptCompression, CScript const&>::Serialize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&) const
Line
Count
Source
476
69.5k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>::Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&) const
Line
Count
Source
476
102k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>::Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&) const
Line
Count
Source
476
270k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>::Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&) const
Line
Count
Source
476
153k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>::Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&) const
Line
Count
Source
476
141k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>::Serialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&) const
Line
Count
Source
476
2.35k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>::Serialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&) const
Line
Count
Source
476
1.21k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>::Serialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&) const
Line
Count
Source
476
2.26k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
block_policy_estimator.cpp:void Wrapper<(anonymous namespace)::EncodedDoubleFormatter, double const&>::Serialize<AutoFile>(AutoFile&) const
Line
Count
Source
476
3.34k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
block_policy_estimator.cpp:void Wrapper<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>, std::vector<double, std::allocator<double>> const&>::Serialize<AutoFile>(AutoFile&) const
Line
Count
Source
476
7.80k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
block_policy_estimator.cpp:void Wrapper<VectorFormatter<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&>::Serialize<AutoFile>(AutoFile&) const
Line
Count
Source
476
6.69k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
mempool_estimator.cpp:void Wrapper<VectorFormatter<(anonymous namespace)::MinedBlockStatsFormatter>, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>> const&>::Serialize<AutoFile>(AutoFile&) const
Line
Count
Source
476
1.11k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CCoin, std::allocator<CCoin>> const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
3
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>::Serialize<AutoFile>(AutoFile&) const
Line
Count
Source
476
7.05k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<TxOutCompression, CTxOut const&>::Serialize<AutoFile>(AutoFile&) const
Line
Count
Source
476
6.58k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<AmountCompression, long const&>::Serialize<AutoFile>(AutoFile&) const
Line
Count
Source
476
6.58k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>::Serialize<AutoFile>(AutoFile&) const
Line
Count
Source
476
6.58k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<ScriptCompression, CScript const&>::Serialize<AutoFile>(AutoFile&) const
Line
Count
Source
476
6.58k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>::Serialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&) const
Line
Count
Source
476
41
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<CustomUintFormatter<4, true>, unsigned int const&>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
476
157k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<TxOutCompression, CTxOut const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
289k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<AmountCompression, long const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
289k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
void Wrapper<ScriptCompression, CScript const&>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
476
289k
    template<typename Stream> void Serialize(Stream &s) const { Formatter().Ser(s, m_object); }
Unexecuted instantiation: void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<unsigned int, std::allocator<unsigned int>> const&>::Serialize<DataStream>(DataStream&) const
477
6.35M
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<4, true>, unsigned int&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
5.90k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
166
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
21.6k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
21.6k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CompactSizeFormatter<true>, unsigned short&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
21.6k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>::Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
477
21.6k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>::Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
477
194k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>::Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
477
115k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>::Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
477
94.2k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
597
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
264
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
220
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
4.59k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
1
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
1
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>::Unserialize<ParamsStream<DataStream&, TransactionSerParams>>(ParamsStream<DataStream&, TransactionSerParams>&)
Line
Count
Source
477
34.8k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>>&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
681
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)1>, int&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
79.0k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
466k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>>&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
681
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>>&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
681
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>>&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
396
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>>&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
375
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
464k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<TxOutCompression, CTxOut&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
89.6k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<AmountCompression, long&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
89.6k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<ScriptCompression, CScript&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
89.6k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<LimitedStringFormatter<256ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>::Unserialize<AutoFile>(AutoFile&)
Line
Count
Source
477
4
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CompactSizeFormatter<true>, unsigned long&>::Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
477
32
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&>::Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&)
Line
Count
Source
477
3
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>::Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&)
Line
Count
Source
477
7
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CompactSizeFormatter<false>, unsigned long&>::Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&)
Line
Count
Source
477
3
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>::Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&)
Line
Count
Source
477
4
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CompactSizeFormatter<true>, unsigned long&>::Unserialize<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
477
3
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<2, true>, unsigned short&>::Unserialize<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
477
7
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
16.8k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>::Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
477
449k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>::Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
477
240k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>::Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
477
294k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<LimitedVectorFormatter<0ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
1
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<LimitedVectorFormatter<10ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
1
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<LimitedVectorFormatter<12ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
1
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<LimitedVectorFormatter<13ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
1
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<LimitedVectorFormatter<14ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
1
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<LimitedVectorFormatter<100ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
1
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)1>, int&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
558k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
279k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>&>::Unserialize<ParamsStream<DataStream&, serialize_tests::BaseFormat>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&)
Line
Count
Source
477
2
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<5, true>, unsigned long&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
326
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<3, true>, unsigned int&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
326
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
1.16M
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<3, true>, unsigned int&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
4
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
130
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>::Unserialize<AutoFile>(AutoFile&)
Line
Count
Source
477
12.7k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<TxOutCompression, CTxOut&>::Unserialize<AutoFile>(AutoFile&)
Line
Count
Source
477
6.35k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<AmountCompression, long&>::Unserialize<AutoFile>(AutoFile&)
Line
Count
Source
477
6.35k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>::Unserialize<AutoFile>(AutoFile&)
Line
Count
Source
477
6.35k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<ScriptCompression, CScript&>::Unserialize<AutoFile>(AutoFile&)
Line
Count
Source
477
6.35k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<4, true>, unsigned int&>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
477
9.39k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
11.4k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
11.4k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&>::Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
Line
Count
Source
477
31
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>::Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
Line
Count
Source
477
20.5k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CompactSizeFormatter<false>, unsigned long&>::Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
Line
Count
Source
477
20.5k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
Unexecuted instantiation: void Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>::Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
void Wrapper<CompactSizeFormatter<true>, unsigned long&>::Unserialize<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
477
20.5k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<2, true>, unsigned short&>::Unserialize<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
477
20.5k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
Unexecuted instantiation: void Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&>::Unserialize<AutoFile>(AutoFile&)
Unexecuted instantiation: void Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>::Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&)
Unexecuted instantiation: void Wrapper<CompactSizeFormatter<false>, unsigned long&>::Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&)
Unexecuted instantiation: void Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>::Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&)
Unexecuted instantiation: void Wrapper<CompactSizeFormatter<true>, unsigned long&>::Unserialize<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Unexecuted instantiation: void Wrapper<CustomUintFormatter<2, true>, unsigned short&>::Unserialize<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Unexecuted instantiation: void Wrapper<CompactSizeFormatter<true>, unsigned long&>::Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&)
Unexecuted instantiation: void Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>::Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&)
void Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&>::Unserialize<HashVerifier<AutoFile>>(HashVerifier<AutoFile>&)
Line
Count
Source
477
639
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CompactSizeFormatter<true>, unsigned long&>::Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
Line
Count
Source
477
20.5k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>::Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
Line
Count
Source
477
20.5k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
7
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>::Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
477
6.91k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CompactSizeFormatter<false>, unsigned long&>::Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
477
1.03k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>::Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
477
5.88k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CompactSizeFormatter<true>, unsigned long&>::Unserialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
477
1.03k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<2, true>, unsigned short&>::Unserialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
477
6.91k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>::Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
477
13
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&>::Unserialize<HashVerifier<DataStream>>(HashVerifier<DataStream>&)
Line
Count
Source
477
2
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>::Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&)
Line
Count
Source
477
4
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CompactSizeFormatter<false>, unsigned long&>::Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&)
Line
Count
Source
477
3
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>::Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&)
Line
Count
Source
477
1
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CompactSizeFormatter<true>, unsigned long&>::Unserialize<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
477
3
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CustomUintFormatter<2, true>, unsigned short&>::Unserialize<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&)
Line
Count
Source
477
4
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<CompactSizeFormatter<true>, unsigned long&>::Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&)
Line
Count
Source
477
3
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>::Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&)
Line
Count
Source
477
4
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>::Unserialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&)
Line
Count
Source
477
972
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>::Unserialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&)
Line
Count
Source
477
500
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>::Unserialize<ParamsStream<AutoFile&, TransactionSerParams>>(ParamsStream<AutoFile&, TransactionSerParams>&)
Line
Count
Source
477
489
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
Unexecuted instantiation: void Wrapper<CompactSizeFormatter<true>, unsigned long&>::Unserialize<ParamsStream<SpanReader, CAddress::SerParams>>(ParamsStream<SpanReader, CAddress::SerParams>&)
Unexecuted instantiation: void Wrapper<CustomUintFormatter<2, true>, unsigned short&>::Unserialize<ParamsStream<SpanReader, CAddress::SerParams>>(ParamsStream<SpanReader, CAddress::SerParams>&)
void Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
1.73k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
Unexecuted instantiation: void Wrapper<CompactSizeFormatter<true>, unsigned long&>::Unserialize<ParamsStream<DataStream&, CNetAddr::SerParams>>(ParamsStream<DataStream&, CNetAddr::SerParams>&)
void Wrapper<CustomUintFormatter<2, true>, unsigned short&>::Unserialize<ParamsStream<DataStream&, CNetAddr::SerParams>>(ParamsStream<DataStream&, CNetAddr::SerParams>&)
Line
Count
Source
477
1.73k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<LimitedStringFormatter<256ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
1.70k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<LimitedStringFormatter<80ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
56
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<LimitedVectorFormatter<512ul, DefaultFormatter>, std::vector<unsigned char, std::allocator<unsigned char>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
52
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&>::Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
477
58
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CInv, std::allocator<CInv>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
39.1k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>>&>::Unserialize<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
477
33.7k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>>&>::Unserialize<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
477
21.0k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>::Unserialize<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
477
93.4k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<TxOutCompression, CTxOut&>::Unserialize<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
477
31.1k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<AmountCompression, long&>::Unserialize<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
477
31.1k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>::Unserialize<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
477
31.1k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<ScriptCompression, CScript&>::Unserialize<HashVerifier<BufferedReader<AutoFile>>>(HashVerifier<BufferedReader<AutoFile>>&)
Line
Count
Source
477
31.1k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>::Unserialize<ParamsStream<SpanReader&, TransactionSerParams>>(ParamsStream<SpanReader&, TransactionSerParams>&)
Line
Count
Source
477
140k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
block_policy_estimator.cpp:void Wrapper<(anonymous namespace)::EncodedDoubleFormatter, double&>::Unserialize<AutoFile>(AutoFile&)
Line
Count
Source
477
1.74k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
block_policy_estimator.cpp:void Wrapper<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>, std::vector<double, std::allocator<double>>&>::Unserialize<AutoFile>(AutoFile&)
Line
Count
Source
477
4.07k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
block_policy_estimator.cpp:void Wrapper<VectorFormatter<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&>::Unserialize<AutoFile>(AutoFile&)
Line
Count
Source
477
3.49k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
mempool_estimator.cpp:void Wrapper<VectorFormatter<(anonymous namespace)::MinedBlockStatsFormatter>, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>>&>::Unserialize<AutoFile>(AutoFile&)
Line
Count
Source
477
587
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<COutPoint, std::allocator<COutPoint>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
2
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<TxOutCompression, CTxOut&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
279k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<AmountCompression, long&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
279k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<ScriptCompression, CScript&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
279k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>::Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
477
1.91k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>::Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
477
3.98k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>::Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
477
2.01k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>::Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>>(ParamsStream<BufferedFile&, TransactionSerParams>&)
Line
Count
Source
477
1.97k
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
void Wrapper<VectorFormatter<DefaultFormatter>, std::vector<unsigned int, std::allocator<unsigned int>>&>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
477
277
    template<typename Stream> void Unserialize(Stream &s) { Formatter().Unser(s, m_object); }
478
};
479
480
/** Cause serialization/deserialization of an object to be done using a specified formatter class.
481
 *
482
 * To use this, you need a class Formatter that has public functions Ser(stream, const object&) for
483
 * serialization, and Unser(stream, object&) for deserialization. Serialization routines (inside
484
 * READWRITE, or directly with << and >> operators), can then use Using<Formatter>(object).
485
 *
486
 * This works by constructing a Wrapper<Formatter, T>-wrapped version of object, where T is
487
 * const during serialization, and non-const during deserialization, which maintains const
488
 * correctness.
489
 */
490
template<typename Formatter, typename T>
491
34.8M
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: main.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: main.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: main.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: main.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
addrman_tests.cpp:Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> Using<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&)
Line
Count
Source
491
23
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrman_tests.cpp:Wrapper<CompactSizeFormatter<false>, unsigned long&> Using<CompactSizeFormatter<false>, unsigned long&>(unsigned long&)
Line
Count
Source
491
18
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrman_tests.cpp:Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&> Using<CustomUintFormatter<8, false>, ServiceFlags const&>(ServiceFlags const&)
Line
Count
Source
491
5
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrman_tests.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long const&> Using<CompactSizeFormatter<true>, unsigned long const&>(unsigned long const&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrman_tests.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short const&> Using<CustomUintFormatter<2, true>, unsigned short const&>(unsigned short const&)
Line
Count
Source
491
23
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrman_tests.cpp:Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> Using<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&)
Line
Count
Source
491
17
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: addrman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: addrman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: addrman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: addrman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: argsman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: argsman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: argsman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: argsman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: banman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: banman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: banman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: banman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: base58_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: base58_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: base58_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: base58_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: baseindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: baseindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: baseindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: baseindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
bip32_tests.cpp:Wrapper<CustomUintFormatter<4, true>, unsigned int const&> Using<CustomUintFormatter<4, true>, unsigned int const&>(unsigned int const&)
Line
Count
Source
491
36
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
bip32_tests.cpp:Wrapper<CustomUintFormatter<4, true>, unsigned int&> Using<CustomUintFormatter<4, true>, unsigned int&>(unsigned int&)
Line
Count
Source
491
228
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: bip32_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: bip32_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: bip32_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: bip32_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: bip324_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: bip324_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: bip324_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: bip324_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
bip352_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
491
44
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: bip352_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: bip352_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: bip352_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: bip352_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: blockchain_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: blockchain_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: blockchain_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: blockchain_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
blockencodings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
491
143
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
491
131
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
491
9
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<CompactSizeFormatter<true>, unsigned short&> Using<CompactSizeFormatter<true>, unsigned short&>(unsigned short&)
Line
Count
Source
491
11
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&> Using<DefaultFormatter, std::shared_ptr<CTransaction const>&>(std::shared_ptr<CTransaction const>&)
Line
Count
Source
491
11
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&>(std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&)
Line
Count
Source
491
9
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>>&> Using<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>>&>(std::vector<unsigned long, std::allocator<unsigned long>>&)
Line
Count
Source
491
9
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
491
3.37k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
491
1.73k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
491
6.13k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<CompactSizeFormatter<true>, unsigned short const&> Using<CompactSizeFormatter<true>, unsigned short const&>(unsigned short const&)
Line
Count
Source
491
11
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&> Using<DefaultFormatter, std::shared_ptr<CTransaction const> const&>(std::shared_ptr<CTransaction const> const&)
Line
Count
Source
491
11
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&>(std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
491
9
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&> Using<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>(std::vector<unsigned long, std::allocator<unsigned long>> const&)
Line
Count
Source
491
9
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&> Using<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&>(std::vector<unsigned short, std::allocator<unsigned short>> const&)
Line
Count
Source
491
2
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings_tests.cpp:Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>>&> Using<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>>&>(std::vector<unsigned short, std::allocator<unsigned short>>&)
Line
Count
Source
491
3
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: blockencodings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: blockfilter_index_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: blockfilter_index_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: blockfilter_index_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: blockfilter_index_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
blockmanager_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
491
1.77M
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockmanager_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
491
1.73M
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockmanager_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
491
47.1k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockmanager_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
491
94.7k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: blockpolicyestimator_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: blockpolicyestimator_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: blockpolicyestimator_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: blockpolicyestimator_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
bloom_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
491
265
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
bloom_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
491
221
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
bloom_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
491
4.59k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
bloom_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
491
9
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
bloom_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>(std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
491
538
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: bloom_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: bloom_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: bloom_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: bloom_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: btcsignals_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: btcsignals_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: btcsignals_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: btcsignals_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: chain_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: chain_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: chain_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: chain_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: chainstate_write_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: chainstate_write_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: chainstate_write_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: chainstate_write_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: checkqueue_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: checkqueue_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: checkqueue_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: checkqueue_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
cluster_linearize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, int&> Using<VarIntFormatter<(VarIntMode)1>, int&>(int&)
Line
Count
Source
491
77.9k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long&>(unsigned long&)
Line
Count
Source
491
449k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>>&> Using<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>>&>(cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>>&)
Line
Count
Source
491
681
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, int const&> Using<VarIntFormatter<(VarIntMode)1>, int const&>(int const&)
Line
Count
Source
491
25.0k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long>(unsigned long&&)
Line
Count
Source
491
50.1k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>> const&> Using<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>> const&>(cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>> const&)
Line
Count
Source
491
227
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>>&> Using<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>>&>(cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>>&)
Line
Count
Source
491
681
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>> const&> Using<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>> const&>(cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>> const&)
Line
Count
Source
491
227
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>>&> Using<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>>&>(cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>>&)
Line
Count
Source
491
681
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>> const&> Using<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>> const&>(cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>> const&)
Line
Count
Source
491
227
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>>&> Using<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>>&>(cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>>&)
Line
Count
Source
491
403
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>> const&> Using<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>> const&>(cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>> const&)
Line
Count
Source
491
132
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>>&> Using<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>>&>(cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>>&)
Line
Count
Source
491
375
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
cluster_linearize_tests.cpp:Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>> const&> Using<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>> const&>(cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>> const&)
Line
Count
Source
491
125
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: cluster_linearize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: cluster_linearize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: cluster_linearize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: cluster_linearize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
coins_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int&>(unsigned int&)
Line
Count
Source
491
126k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
coins_tests.cpp:Wrapper<AmountCompression, long&> Using<AmountCompression, long&>(long&)
Line
Count
Source
491
63.0k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
coins_tests.cpp:Wrapper<ScriptCompression, CScript&> Using<ScriptCompression, CScript&>(CScript&)
Line
Count
Source
491
63.0k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
coins_tests.cpp:Wrapper<TxOutCompression, CTxOut&> Using<TxOutCompression, CTxOut&>(CTxOut&)
Line
Count
Source
491
63.0k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
coins_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long&>(unsigned long&)
Line
Count
Source
491
63.0k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: coins_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: coins_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: coins_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: coins_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: coinstatsindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: coinstatsindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: coinstatsindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: coinstatsindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: compress_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: compress_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: compress_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: compress_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: crypto_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: crypto_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: crypto_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: crypto_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: cuckoocache_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: cuckoocache_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: cuckoocache_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: cuckoocache_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: dbwrapper_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: dbwrapper_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: dbwrapper_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: dbwrapper_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
denialofservice_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
491
7
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
denialofservice_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
491
7
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: denialofservice_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: denialofservice_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: descriptor_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: descriptor_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: descriptor_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: descriptor_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: disconnected_transactions.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: disconnected_transactions.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: disconnected_transactions.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: disconnected_transactions.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
flatfile_tests.cpp:Wrapper<LimitedStringFormatter<256ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&> Using<LimitedStringFormatter<256ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
491
7
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: flatfile_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: flatfile_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: flatfile_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: flatfile_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: fs_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: fs_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: fs_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: fs_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: getarg_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: getarg_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: getarg_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: getarg_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
hash_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
491
1.54M
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
hash_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
491
1.51M
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
hash_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
491
41.7k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: hash_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: headers_sync_chainwork_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: headers_sync_chainwork_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: headers_sync_chainwork_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: headers_sync_chainwork_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: httpserver_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: httpserver_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: httpserver_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: httpserver_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: i2p_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: i2p_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: i2p_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: i2p_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: interfaces_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: interfaces_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: interfaces_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: interfaces_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: key_io_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: key_io_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: key_io_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: key_io_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: key_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: key_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: key_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: key_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: logging_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: logging_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: logging_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: logging_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: mempool_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: mempool_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: mempool_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: mempool_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: mempool_fee_estimator_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: mempool_fee_estimator_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: mempool_fee_estimator_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: mempool_fee_estimator_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: merkle_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: merkle_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: merkle_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: merkle_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: merkleblock_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: merkleblock_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: merkleblock_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: merkleblock_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: miner_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: miner_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: miner_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: miner_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: miniminer_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: miniminer_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: miniminer_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: miniminer_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
miniscript_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
491
19.8k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: miniscript_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: miniscript_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: miniscript_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: minisketch_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: minisketch_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: minisketch_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: minisketch_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: multisig_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: multisig_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: multisig_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: multisig_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: bip328_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: bip328_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: bip328_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: bip328_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: net_peer_connection_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: net_peer_connection_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: net_peer_connection_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: net_peer_connection_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: net_peer_eviction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: net_peer_eviction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: net_peer_eviction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: net_peer_eviction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: net_tests.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long const&> Using<CompactSizeFormatter<true>, unsigned long const&>(unsigned long const&)
net_tests.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long&> Using<CompactSizeFormatter<true>, unsigned long&>(unsigned long&)
Line
Count
Source
491
35
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_tests.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short const&> Using<CustomUintFormatter<2, true>, unsigned short const&>(unsigned short const&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_tests.cpp:Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&> Using<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
491
7
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_tests.cpp:Wrapper<CompactSizeFormatter<false>, unsigned long&> Using<CompactSizeFormatter<false>, unsigned long&>(unsigned long&)
Line
Count
Source
491
3
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_tests.cpp:Wrapper<CustomUintFormatter<8, false>, ServiceFlags&> Using<CustomUintFormatter<8, false>, ServiceFlags&>(ServiceFlags&)
Line
Count
Source
491
4
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_tests.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short&> Using<CustomUintFormatter<2, true>, unsigned short&>(unsigned short&)
Line
Count
Source
491
7
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&>(std::vector<CAddress, std::allocator<CAddress>>&)
Line
Count
Source
491
3
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: net_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: net_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: net_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: net_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> Using<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<CompactSizeFormatter<false>, unsigned long&> Using<CompactSizeFormatter<false>, unsigned long&>(unsigned long&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&> Using<CustomUintFormatter<8, false>, ServiceFlags const&>(ServiceFlags const&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long const&> Using<CompactSizeFormatter<true>, unsigned long const&>(unsigned long const&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short const&> Using<CustomUintFormatter<2, true>, unsigned short const&>(unsigned short const&)
netbase_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&>(std::vector<CAddress, std::allocator<CAddress>> const&)
Line
Count
Source
491
2
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: netbase_tests.cpp:Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&> Using<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<CustomUintFormatter<8, false>, ServiceFlags&> Using<CustomUintFormatter<8, false>, ServiceFlags&>(ServiceFlags&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long&> Using<CompactSizeFormatter<true>, unsigned long&>(unsigned long&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short&> Using<CustomUintFormatter<2, true>, unsigned short&>(unsigned short&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&>(std::vector<CAddress, std::allocator<CAddress>>&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: netbase_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: node_init_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: node_init_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: node_init_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: node_init_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: node_warnings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: node_warnings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: node_warnings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: node_warnings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: orphanage_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: orphanage_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: orphanage_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: orphanage_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: pcp_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: pcp_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: pcp_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: pcp_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: peerman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: peerman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: peerman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: peerman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: pmt_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>(std::vector<uint256, std::allocator<uint256>> const&)
pmt_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>(std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
491
249
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: pmt_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: pmt_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: pmt_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: pmt_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: pool_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: pool_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: pool_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: pool_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: pow_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: pow_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: pow_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: pow_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
prevector_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<int, std::allocator<int>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<int, std::allocator<int>> const&>(std::vector<int, std::allocator<int>> const&)
Line
Count
Source
491
265k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
prevector_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, prevector<8u, int, unsigned int, int> const&> Using<VectorFormatter<DefaultFormatter>, prevector<8u, int, unsigned int, int> const&>(prevector<8u, int, unsigned int, int> const&)
Line
Count
Source
491
265k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: prevector_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: prevector_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: prevector_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: prevector_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: private_broadcast_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: private_broadcast_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: private_broadcast_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: private_broadcast_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: psbt_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: psbt_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: psbt_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: psbt_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: random_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: random_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: random_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: random_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: rbf_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: rbf_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: rbf_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: rbf_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: rest_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: rest_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: rest_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: rest_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: rpc_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: rpc_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: rpc_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: rpc_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: sanity_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: sanity_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: sanity_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: sanity_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
script_assets_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
491
11.2k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
script_assets_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
491
7.10k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
script_assets_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
491
4.09k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: script_p2sh_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: script_p2sh_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: script_p2sh_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: script_p2sh_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: script_segwit_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: script_segwit_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: script_segwit_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: script_segwit_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: script_standard_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: script_standard_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: script_standard_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: script_standard_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: script_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: script_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: script_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: script_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: script_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: script_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: script_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: scriptnum_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: scriptnum_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: scriptnum_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: scriptnum_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: serfloat_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: serfloat_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: serfloat_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: serfloat_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: serialize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<int, std::allocator<int>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<int, std::allocator<int>> const&>(std::vector<int, std::allocator<int>> const&)
serialize_tests.cpp:Wrapper<LimitedVectorFormatter<0ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&> Using<LimitedVectorFormatter<0ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>(std::vector<int, std::allocator<int>>&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<LimitedVectorFormatter<10ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&> Using<LimitedVectorFormatter<10ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>(std::vector<int, std::allocator<int>>&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<LimitedVectorFormatter<12ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&> Using<LimitedVectorFormatter<12ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>(std::vector<int, std::allocator<int>>&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<LimitedVectorFormatter<13ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&> Using<LimitedVectorFormatter<13ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>(std::vector<int, std::allocator<int>>&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<LimitedVectorFormatter<14ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&> Using<LimitedVectorFormatter<14ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>(std::vector<int, std::allocator<int>>&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<LimitedVectorFormatter<100ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&> Using<LimitedVectorFormatter<100ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>(std::vector<int, std::allocator<int>>&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, int&> Using<VarIntFormatter<(VarIntMode)1>, int&>(int&)
Line
Count
Source
491
300k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long&>(unsigned long&)
Line
Count
Source
491
303
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, int&> Using<VarIntFormatter<(VarIntMode)1>, int>(int&&)
Line
Count
Source
491
7
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, signed char&> Using<VarIntFormatter<(VarIntMode)1>, signed char>(signed char&&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned char&> Using<VarIntFormatter<(VarIntMode)0>, unsigned char>(unsigned char&&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, short&> Using<VarIntFormatter<(VarIntMode)1>, short>(short&&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned short&> Using<VarIntFormatter<(VarIntMode)0>, unsigned short>(unsigned short&&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int>(unsigned int&&)
Line
Count
Source
491
3
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, long long&> Using<VarIntFormatter<(VarIntMode)1>, long long>(long long&&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long long&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long long>(unsigned long long&&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: serialize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: serialize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: serialize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: serialize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: serialize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: serialize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
serialize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>> const&>(std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>> const&)
Line
Count
Source
491
2
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
serialize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>&>(std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>&)
Line
Count
Source
491
2
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: serialize_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: settings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: settings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: settings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: settings_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: sighash_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: sighash_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: sighash_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: sighash_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: sighash_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: sighash_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: sighash_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: sigopcount_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: sigopcount_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: sigopcount_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: sigopcount_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: skiplist_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: skiplist_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: skiplist_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: skiplist_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: sock_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: sock_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: sock_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: sock_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
streams_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int&>(unsigned int&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: streams_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: streams_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: streams_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: streams_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: system_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: system_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: system_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: system_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: testnet4_miner_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: testnet4_miner_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: testnet4_miner_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: testnet4_miner_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: timeoffsets_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: timeoffsets_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: timeoffsets_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: timeoffsets_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: txdownload_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txdownload_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txdownload_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txdownload_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
txindex_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int&>(unsigned int&)
Line
Count
Source
491
251
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex_tests.cpp:Wrapper<CustomUintFormatter<3, true>, unsigned int&> Using<CustomUintFormatter<3, true>, unsigned int&>(unsigned int&)
Line
Count
Source
491
251
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex_tests.cpp:Wrapper<CustomUintFormatter<5, true>, unsigned long&> Using<CustomUintFormatter<5, true>, unsigned long&>(unsigned long&)
Line
Count
Source
491
247
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int const&>(unsigned int const&)
Line
Count
Source
491
2.14k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex_tests.cpp:Wrapper<CustomUintFormatter<3, true>, unsigned int const&> Using<CustomUintFormatter<3, true>, unsigned int const&>(unsigned int const&)
Line
Count
Source
491
849
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex_tests.cpp:Wrapper<CustomUintFormatter<5, true>, unsigned long const&> Using<CustomUintFormatter<5, true>, unsigned long const&>(unsigned long const&)
Line
Count
Source
491
845
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, int const&> Using<VarIntFormatter<(VarIntMode)1>, int const&>(int const&)
Line
Count
Source
491
550
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: txindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>(std::vector<uint256, std::allocator<uint256>> const&)
txindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>(std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
491
19
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: txindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: txospenderindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txospenderindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txospenderindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txospenderindex_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: txpackage_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txpackage_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txpackage_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txpackage_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: txpackage_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: txpackage_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: txpackage_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: txreconciliation_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txreconciliation_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txreconciliation_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txreconciliation_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: txrequest_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txrequest_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txrequest_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txrequest_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: txvalidation_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txvalidation_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txvalidation_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txvalidation_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: txvalidationcache_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txvalidationcache_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txvalidationcache_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txvalidationcache_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: util_expected_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: util_expected_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: util_expected_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: util_expected_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: util_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: util_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: util_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: util_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: util_trace_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: util_trace_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: util_trace_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: util_trace_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: validation_block_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: validation_block_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: validation_block_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: validation_block_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: validation_chainstate_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: validation_chainstate_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: validation_chainstate_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: validation_chainstate_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
validation_chainstatemanager_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int&>(unsigned int&)
Line
Count
Source
491
3.73k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation_chainstatemanager_tests.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long&>(unsigned long&)
Line
Count
Source
491
1.86k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation_chainstatemanager_tests.cpp:Wrapper<AmountCompression, long&> Using<AmountCompression, long&>(long&)
Line
Count
Source
491
1.86k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation_chainstatemanager_tests.cpp:Wrapper<ScriptCompression, CScript&> Using<ScriptCompression, CScript&>(CScript&)
Line
Count
Source
491
1.86k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation_chainstatemanager_tests.cpp:Wrapper<TxOutCompression, CTxOut&> Using<TxOutCompression, CTxOut&>(CTxOut&)
Line
Count
Source
491
1.86k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: validation_chainstatemanager_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: validation_chainstatemanager_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: validation_chainstatemanager_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: validation_chainstatemanager_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: validation_flush_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: validation_flush_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: validation_flush_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: validation_flush_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: validation_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: validation_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: validation_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: validation_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: validationinterface_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: validationinterface_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: validationinterface_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: validationinterface_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: versionbits_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: versionbits_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: versionbits_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: versionbits_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: init_test_fixture.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: init_test_fixture.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: init_test_fixture.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: init_test_fixture.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: wallet_test_fixture.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: wallet_test_fixture.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: wallet_test_fixture.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: wallet_test_fixture.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: db_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: db_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: db_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: db_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: coinselector_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: coinselector_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: coinselector_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: coinselector_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: coinselection_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: coinselection_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: coinselection_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: coinselection_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: feebumper_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: feebumper_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: feebumper_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: feebumper_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: group_outputs_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: group_outputs_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: group_outputs_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: group_outputs_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: init_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: init_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: init_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: init_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: ismine_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: ismine_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: ismine_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: ismine_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: psbt_wallet_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: psbt_wallet_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: psbt_wallet_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
psbt_wallet_tests.cpp:Wrapper<CustomUintFormatter<4, true>, unsigned int&> Using<CustomUintFormatter<4, true>, unsigned int&>(unsigned int&)
Line
Count
Source
491
714
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: psbt_wallet_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: psbt_wallet_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: psbt_wallet_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: psbt_wallet_tests.cpp:Wrapper<CustomUintFormatter<4, true>, unsigned int const&> Using<CustomUintFormatter<4, true>, unsigned int const&>(unsigned int const&)
Unexecuted instantiation: psbt_wallet_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: rescan_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: rescan_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: rescan_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: rescan_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: scriptpubkeyman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: scriptpubkeyman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: scriptpubkeyman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: scriptpubkeyman_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: spend_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: spend_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: spend_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: spend_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: wallet_crypto_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: wallet_crypto_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: wallet_crypto_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: wallet_crypto_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: wallet_interfaces_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: wallet_interfaces_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: wallet_interfaces_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: wallet_interfaces_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: wallet_rpc_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: wallet_rpc_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: wallet_rpc_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: wallet_rpc_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: wallet_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: wallet_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: wallet_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: wallet_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: wallet_transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: wallet_transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: wallet_transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
wallet_transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&>(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
Line
Count
Source
491
832
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: wallet_transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: wallet_transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: wallet_transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: wallet_transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>(std::vector<uint256, std::allocator<uint256>>&)
wallet_transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&>(std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&)
Line
Count
Source
491
3
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
wallet_transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&>(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
Line
Count
Source
491
3
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: wallet_transaction_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: walletdb_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: walletdb_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: walletdb_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: walletdb_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: walletload_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: walletload_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: walletload_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: walletload_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: ipc_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: ipc_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: ipc_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: ipc_tests.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: ipc_test.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: ipc_test.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: ipc_test.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: ipc_test.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: ipc_test.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: ipc_test.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: ipc_test.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: ipc_test.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: ipc_test.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: ipc_test.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: ipc_test.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: ipc_test.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: ipc_test.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: ipc_test.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: ipc_test.capnp.proxy-types.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: ipc_test.capnp.proxy-types.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: ipc_test.capnp.proxy-types.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: ipc_test.capnp.proxy-types.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: blockfilter.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: blockfilter.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: blockfilter.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: blockfilter.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: mining.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: mining.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: mining.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
mining.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
491
41
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net.cpp:Wrapper<CustomUintFormatter<8, false>, ServiceFlags&> Using<CustomUintFormatter<8, false>, ServiceFlags&>(ServiceFlags&)
Line
Count
Source
491
5
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: net.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long const&> Using<CompactSizeFormatter<true>, unsigned long const&>(unsigned long const&)
net.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short const&> Using<CustomUintFormatter<2, true>, unsigned short const&>(unsigned short const&)
Line
Count
Source
491
20
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: net.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: net.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: net.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: net.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: setup_common.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: setup_common.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: setup_common.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: setup_common.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Unexecuted instantiation: setup_common.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: setup_common.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: setup_common.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: setup_common.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: transaction_utils.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: transaction_utils.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: transaction_utils.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: transaction_utils.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: txmempool.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txmempool.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txmempool.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txmempool.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: validation.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: validation.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: validation.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: validation.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: util.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: util.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: util.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: util.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
addrdb.cpp:Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> Using<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&)
Line
Count
Source
491
50.3k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrdb.cpp:Wrapper<CompactSizeFormatter<false>, unsigned long&> Using<CompactSizeFormatter<false>, unsigned long&>(unsigned long&)
Line
Count
Source
491
70.8k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: addrdb.cpp:Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&> Using<CustomUintFormatter<8, false>, ServiceFlags const&>(ServiceFlags const&)
Unexecuted instantiation: addrdb.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long const&> Using<CompactSizeFormatter<true>, unsigned long const&>(unsigned long const&)
addrdb.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short const&> Using<CustomUintFormatter<2, true>, unsigned short const&>(unsigned short const&)
Line
Count
Source
491
50.3k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&>(std::vector<CAddress, std::allocator<CAddress>> const&)
Line
Count
Source
491
39
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrdb.cpp:Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&> Using<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
491
20.5k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: addrdb.cpp:Wrapper<CustomUintFormatter<8, false>, ServiceFlags&> Using<CustomUintFormatter<8, false>, ServiceFlags&>(ServiceFlags&)
addrdb.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long&> Using<CompactSizeFormatter<true>, unsigned long&>(unsigned long&)
Line
Count
Source
491
20.5k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrdb.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short&> Using<CustomUintFormatter<2, true>, unsigned short&>(unsigned short&)
Line
Count
Source
491
20.5k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&>(std::vector<CAddress, std::allocator<CAddress>>&)
Line
Count
Source
491
31
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: addrman.cpp:Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> Using<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&)
addrman.cpp:Wrapper<CompactSizeFormatter<false>, unsigned long&> Using<CompactSizeFormatter<false>, unsigned long&>(unsigned long&)
Line
Count
Source
491
15
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: addrman.cpp:Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&> Using<CustomUintFormatter<8, false>, ServiceFlags const&>(ServiceFlags const&)
Unexecuted instantiation: addrman.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long const&> Using<CompactSizeFormatter<true>, unsigned long const&>(unsigned long const&)
Unexecuted instantiation: addrman.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short const&> Using<CustomUintFormatter<2, true>, unsigned short const&>(unsigned short const&)
addrman.cpp:Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> Using<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&)
Line
Count
Source
491
50.3k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrman.cpp:Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&> Using<CustomUintFormatter<1, false>, AddrManImpl::Format&>(AddrManImpl::Format&)
Line
Count
Source
491
648
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrman.cpp:Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&> Using<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
491
17
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrman.cpp:Wrapper<CustomUintFormatter<8, false>, ServiceFlags&> Using<CustomUintFormatter<8, false>, ServiceFlags&>(ServiceFlags&)
Line
Count
Source
491
2
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrman.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long&> Using<CompactSizeFormatter<true>, unsigned long&>(unsigned long&)
Line
Count
Source
491
20.5k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrman.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short&> Using<CustomUintFormatter<2, true>, unsigned short&>(unsigned short&)
Line
Count
Source
491
17
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
addrman.cpp:Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&> Using<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
491
20.5k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: blockencodings.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: blockencodings.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: blockencodings.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
blockencodings.cpp:Wrapper<CompactSizeFormatter<true>, unsigned short const&> Using<CompactSizeFormatter<true>, unsigned short const&>(unsigned short const&)
Line
Count
Source
491
35.7k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings.cpp:Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&> Using<DefaultFormatter, std::shared_ptr<CTransaction const> const&>(std::shared_ptr<CTransaction const> const&)
Line
Count
Source
491
35.7k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&>(std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
491
35.6k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockencodings.cpp:Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&> Using<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>(std::vector<unsigned long, std::allocator<unsigned long>> const&)
Line
Count
Source
491
35.6k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: blockencodings.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: tx_verify.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: tx_verify.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: tx_verify.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: tx_verify.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: base.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>(std::vector<uint256, std::allocator<uint256>>&)
Unexecuted instantiation: base.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>(std::vector<uint256, std::allocator<uint256>> const&)
Unexecuted instantiation: base.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: base.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: base.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: base.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
blockfilterindex.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, int&> Using<VarIntFormatter<(VarIntMode)1>, int&>(int&)
Line
Count
Source
491
4.09k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockfilterindex.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int&>(unsigned int&)
Line
Count
Source
491
4.09k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockfilterindex.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, int const&> Using<VarIntFormatter<(VarIntMode)1>, int const&>(int const&)
Line
Count
Source
491
7.78k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockfilterindex.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int const&>(unsigned int const&)
Line
Count
Source
491
7.78k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: coinstatsindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: coinstatsindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: coinstatsindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: coinstatsindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: txindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>(std::vector<uint256, std::allocator<uint256>>&)
Unexecuted instantiation: txindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>(std::vector<uint256, std::allocator<uint256>> const&)
txindex.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int const&>(unsigned int const&)
Line
Count
Source
491
7.31k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex.cpp:Wrapper<CustomUintFormatter<3, true>, unsigned int const&> Using<CustomUintFormatter<3, true>, unsigned int const&>(unsigned int const&)
Line
Count
Source
491
3.73k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex.cpp:Wrapper<CustomUintFormatter<5, true>, unsigned long const&> Using<CustomUintFormatter<5, true>, unsigned long const&>(unsigned long const&)
Line
Count
Source
491
3.73k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int&>(unsigned int&)
Line
Count
Source
491
108
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex.cpp:Wrapper<CustomUintFormatter<3, true>, unsigned int&> Using<CustomUintFormatter<3, true>, unsigned int&>(unsigned int&)
Line
Count
Source
491
79
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex.cpp:Wrapper<CustomUintFormatter<5, true>, unsigned long&> Using<CustomUintFormatter<5, true>, unsigned long&>(unsigned long&)
Line
Count
Source
491
79
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
491
240
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
491
127
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
491
113
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: txindex.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, int&> Using<VarIntFormatter<(VarIntMode)1>, int&>(int&)
Unexecuted instantiation: txindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: txospenderindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txospenderindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txospenderindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txospenderindex.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, int const&> Using<VarIntFormatter<(VarIntMode)1>, int const&>(int const&)
txospenderindex.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int const&>(unsigned int const&)
Line
Count
Source
491
34
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: txospenderindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: txospenderindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: txospenderindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: txospenderindex.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, int&> Using<VarIntFormatter<(VarIntMode)1>, int&>(int&)
Unexecuted instantiation: txospenderindex.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int&>(unsigned int&)
Unexecuted instantiation: txospenderindex.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: init.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: init.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: init.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: init.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: coinstats.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: coinstats.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: coinstats.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: coinstats.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: net.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long&> Using<CompactSizeFormatter<true>, unsigned long&>(unsigned long&)
Unexecuted instantiation: net.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short&> Using<CustomUintFormatter<2, true>, unsigned short&>(unsigned short&)
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
491
92.2k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
491
59.3k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
491
42.0k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<CompactSizeFormatter<true>, unsigned short const&> Using<CompactSizeFormatter<true>, unsigned short const&>(unsigned short const&)
Line
Count
Source
491
18.8k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&> Using<DefaultFormatter, std::shared_ptr<CTransaction const> const&>(std::shared_ptr<CTransaction const> const&)
Line
Count
Source
491
18.8k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&>(std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
491
18.8k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&> Using<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>(std::vector<unsigned long, std::allocator<unsigned long>> const&)
Line
Count
Source
491
18.8k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CInv, std::allocator<CInv>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CInv, std::allocator<CInv>> const&>(std::vector<CInv, std::allocator<CInv>> const&)
Line
Count
Source
491
58.7k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
491
35.6k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>(std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
491
3.01k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<CustomUintFormatter<8, false>, ServiceFlags&> Using<CustomUintFormatter<8, false>, ServiceFlags&>(ServiceFlags&)
Line
Count
Source
491
7.61k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long&> Using<CompactSizeFormatter<true>, unsigned long&>(unsigned long&)
Line
Count
Source
491
1.02k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short&> Using<CustomUintFormatter<2, true>, unsigned short&>(unsigned short&)
Line
Count
Source
491
8.64k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<LimitedStringFormatter<256ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&> Using<LimitedStringFormatter<256ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
491
1.70k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: net_processing.cpp:Wrapper<CompactSizeFormatter<true>, unsigned long const&> Using<CompactSizeFormatter<true>, unsigned long const&>(unsigned long const&)
net_processing.cpp:Wrapper<CustomUintFormatter<2, true>, unsigned short const&> Using<CustomUintFormatter<2, true>, unsigned short const&>(unsigned short const&)
Line
Count
Source
491
22.4k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<LimitedStringFormatter<80ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&> Using<LimitedStringFormatter<80ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
491
56
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<LimitedVectorFormatter<512ul, DefaultFormatter>, std::vector<unsigned char, std::allocator<unsigned char>>&> Using<LimitedVectorFormatter<512ul, DefaultFormatter>, std::vector<unsigned char, std::allocator<unsigned char>>&>(std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
491
52
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&> Using<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
491
6.90k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<CompactSizeFormatter<false>, unsigned long&> Using<CompactSizeFormatter<false>, unsigned long&>(unsigned long&)
Line
Count
Source
491
1.05k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&>(std::vector<CAddress, std::allocator<CAddress>>&)
Line
Count
Source
491
58
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CInv, std::allocator<CInv>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CInv, std::allocator<CInv>>&>(std::vector<CInv, std::allocator<CInv>>&)
Line
Count
Source
491
39.1k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>(std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
491
16.6k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>>&> Using<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>>&>(std::vector<unsigned short, std::allocator<unsigned short>>&)
Line
Count
Source
491
594
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CBlockHeader, std::allocator<CBlockHeader>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CBlockHeader, std::allocator<CBlockHeader>> const&>(std::vector<CBlockHeader, std::allocator<CBlockHeader>> const&)
Line
Count
Source
491
9
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CBlock, std::allocator<CBlock>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CBlock, std::allocator<CBlock>> const&>(std::vector<CBlock, std::allocator<CBlock>> const&)
Line
Count
Source
491
5.27k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
491
194k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
491
114k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
491
94.1k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<CompactSizeFormatter<true>, unsigned short&> Using<CompactSizeFormatter<true>, unsigned short&>(unsigned short&)
Line
Count
Source
491
21.6k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&> Using<DefaultFormatter, std::shared_ptr<CTransaction const>&>(std::shared_ptr<CTransaction const>&)
Line
Count
Source
491
21.6k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&>(std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&)
Line
Count
Source
491
21.6k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>>&> Using<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>>&>(std::vector<unsigned long, std::allocator<unsigned long>>&)
Line
Count
Source
491
21.6k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&> Using<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&>(std::vector<unsigned short, std::allocator<unsigned short>> const&)
Line
Count
Source
491
577
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
491
34.8k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> Using<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>(std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&)
Line
Count
Source
491
18.9k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&> Using<CustomUintFormatter<8, false>, ServiceFlags const&>(ServiceFlags const&)
Line
Count
Source
491
18.9k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
net_processing.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&>(std::vector<CAddress, std::allocator<CAddress>> const&)
Line
Count
Source
491
134
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: block_template_manager.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: block_template_manager.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: block_template_manager.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: block_template_manager.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: blockmanager_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: blockmanager_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: blockmanager_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: blockmanager_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
blockstorage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
491
2.94M
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
491
2.13M
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
491
1.04M
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
491
718k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int&>(unsigned int&)
Line
Count
Source
491
1.09M
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long&>(unsigned long&)
Line
Count
Source
491
32.8k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int const&>(unsigned int const&)
Line
Count
Source
491
439k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long const&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long const&>(unsigned long const&)
Line
Count
Source
491
3.44k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, int&> Using<VarIntFormatter<(VarIntMode)1>, int&>(int&)
Line
Count
Source
491
573k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VarIntFormatter<(VarIntMode)1>, int const&> Using<VarIntFormatter<(VarIntMode)1>, int const&>(int const&)
Line
Count
Source
491
217k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<AmountCompression, long&> Using<AmountCompression, long&>(long&)
Line
Count
Source
491
31.1k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<ScriptCompression, CScript&> Using<ScriptCompression, CScript&>(CScript&)
Line
Count
Source
491
31.1k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<TxOutCompression, CTxOut&> Using<TxOutCompression, CTxOut&>(CTxOut&)
Line
Count
Source
491
31.1k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>>&> Using<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>>&>(std::vector<Coin, std::allocator<Coin>>&)
Line
Count
Source
491
21.0k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>>&>(std::vector<CTxUndo, std::allocator<CTxUndo>>&)
Line
Count
Source
491
33.7k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long>(unsigned long&&)
Line
Count
Source
491
208k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<AmountCompression, long const&> Using<AmountCompression, long const&>(long const&)
Line
Count
Source
491
208k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<ScriptCompression, CScript const&> Using<ScriptCompression, CScript const&>(CScript const&)
Line
Count
Source
491
208k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<TxOutCompression, CTxOut const&> Using<TxOutCompression, CTxOut const&>(CTxOut const&)
Line
Count
Source
491
208k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&> Using<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>(std::vector<Coin, std::allocator<Coin>> const&)
Line
Count
Source
491
135k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>> const&>(std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
491
302k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
491
438k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
491
233k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
491
289k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockstorage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
491
140k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: chainstate.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: chainstate.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: chainstate.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: chainstate.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: chainstatemanager_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: chainstatemanager_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: chainstatemanager_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: chainstatemanager_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: context.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: context.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: context.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: context.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: interfaces.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: interfaces.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: interfaces.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: interfaces.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: mempool_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: mempool_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: mempool_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: mempool_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
mempool_persist.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
491
732
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
mempool_persist.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
491
373
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
mempool_persist.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
491
376
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
mempool_persist.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
491
2.35k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
mempool_persist.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
491
1.21k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
mempool_persist.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
491
2.26k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: mempool_persist.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: mempool_persist_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: mempool_persist_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: mempool_persist_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: mempool_persist_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: miner.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: miner.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: miner.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: miner.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: mining_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: mining_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: mining_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: mining_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: mini_miner.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: mini_miner.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: mini_miner.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: mini_miner.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: peerman_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: peerman_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: peerman_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: peerman_args.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
transaction.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
491
1.27M
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
transaction.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
491
902k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
transaction.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
491
515k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: transaction.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: txdownloadman_impl.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txdownloadman_impl.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txdownloadman_impl.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txdownloadman_impl.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: txorphanage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txorphanage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txorphanage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txorphanage.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: utxo_snapshot.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: utxo_snapshot.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: utxo_snapshot.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: utxo_snapshot.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: ephemeral_policy.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: ephemeral_policy.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: ephemeral_policy.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: ephemeral_policy.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
block_policy_estimator.cpp:Wrapper<(anonymous namespace)::EncodedDoubleFormatter, double const&> Using<(anonymous namespace)::EncodedDoubleFormatter, double const&>(double const&)
Line
Count
Source
491
3.34k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
block_policy_estimator.cpp:Wrapper<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>, std::vector<double, std::allocator<double>> const&> Using<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>, std::vector<double, std::allocator<double>> const&>(std::vector<double, std::allocator<double>> const&)
Line
Count
Source
491
7.80k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
block_policy_estimator.cpp:Wrapper<VectorFormatter<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&> Using<VectorFormatter<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&>(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&)
Line
Count
Source
491
6.69k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
block_policy_estimator.cpp:Wrapper<(anonymous namespace)::EncodedDoubleFormatter, double&> Using<(anonymous namespace)::EncodedDoubleFormatter, double&>(double&)
Line
Count
Source
491
1.74k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
block_policy_estimator.cpp:Wrapper<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>, std::vector<double, std::allocator<double>>&> Using<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>, std::vector<double, std::allocator<double>>&>(std::vector<double, std::allocator<double>>&)
Line
Count
Source
491
4.07k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
block_policy_estimator.cpp:Wrapper<VectorFormatter<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&> Using<VectorFormatter<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&>(std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
Line
Count
Source
491
3.49k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: block_policy_estimator.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: block_policy_estimator.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: block_policy_estimator.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: block_policy_estimator.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: mempool_estimator.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: mempool_estimator.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: mempool_estimator.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
mempool_estimator.cpp:Wrapper<VectorFormatter<(anonymous namespace)::MinedBlockStatsFormatter>, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>>&> Using<VectorFormatter<(anonymous namespace)::MinedBlockStatsFormatter>, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>>&>(std::vector<MinedBlockStats, std::allocator<MinedBlockStats>>&)
Line
Count
Source
491
587
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
mempool_estimator.cpp:Wrapper<VectorFormatter<(anonymous namespace)::MinedBlockStatsFormatter>, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>> const&> Using<VectorFormatter<(anonymous namespace)::MinedBlockStatsFormatter>, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>> const&>(std::vector<MinedBlockStats, std::allocator<MinedBlockStats>> const&)
Line
Count
Source
491
1.11k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: mempool_estimator.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: packages.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: packages.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: packages.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: packages.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: rbf.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: rbf.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: rbf.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: rbf.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: settings.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: settings.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: settings.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: settings.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: truc_policy.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: truc_policy.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: truc_policy.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: truc_policy.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
rest.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
491
192k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
rest.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
491
99.2k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
rest.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
491
110k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: rest.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: rest.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: rest.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: rest.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
rest.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<COutPoint, std::allocator<COutPoint>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<COutPoint, std::allocator<COutPoint>>&>(std::vector<COutPoint, std::allocator<COutPoint>>&)
Line
Count
Source
491
2
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
rest.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CCoin, std::allocator<CCoin>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CCoin, std::allocator<CCoin>> const&>(std::vector<CCoin, std::allocator<CCoin>> const&)
Line
Count
Source
491
3
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: rest.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
blockchain.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int&>(unsigned int&)
Line
Count
Source
491
7.05k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockchain.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long>(unsigned long&&)
Line
Count
Source
491
6.58k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockchain.cpp:Wrapper<AmountCompression, long const&> Using<AmountCompression, long const&>(long const&)
Line
Count
Source
491
6.58k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockchain.cpp:Wrapper<ScriptCompression, CScript const&> Using<ScriptCompression, CScript const&>(CScript const&)
Line
Count
Source
491
6.58k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
blockchain.cpp:Wrapper<TxOutCompression, CTxOut const&> Using<TxOutCompression, CTxOut const&>(CTxOut const&)
Line
Count
Source
491
6.58k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: blockchain.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: blockchain.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: blockchain.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: blockchain.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: blockchain.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: blockchain.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: blockchain.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Unexecuted instantiation: blockchain.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: fees.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: fees.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: fees.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: fees.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: mempool.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: mempool.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: mempool.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: mempool.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: node.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: node.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: node.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: node.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
rawtransaction.cpp:Wrapper<CustomUintFormatter<4, true>, unsigned int const&> Using<CustomUintFormatter<4, true>, unsigned int const&>(unsigned int const&)
Line
Count
Source
491
156k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: rawtransaction.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: rawtransaction.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
rawtransaction.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
491
96.8k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: rawtransaction.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: server_util.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: server_util.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: server_util.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: server_util.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
txoutproof.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>(std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
491
29.4k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txoutproof.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>(std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
491
111
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: txoutproof.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: txoutproof.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: txoutproof.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: txoutproof.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
signet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
491
122
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: signet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: signet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: signet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: signet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
txdb.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int&>(unsigned int&)
Line
Count
Source
491
7.00M
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txdb.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long&>(unsigned long&)
Line
Count
Source
491
306k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txdb.cpp:Wrapper<AmountCompression, long&> Using<AmountCompression, long&>(long&)
Line
Count
Source
491
306k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txdb.cpp:Wrapper<ScriptCompression, CScript&> Using<ScriptCompression, CScript&>(CScript&)
Line
Count
Source
491
306k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txdb.cpp:Wrapper<TxOutCompression, CTxOut&> Using<TxOutCompression, CTxOut&>(CTxOut&)
Line
Count
Source
491
306k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: txdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>(std::vector<uint256, std::allocator<uint256>>&)
Unexecuted instantiation: txdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>(std::vector<uint256, std::allocator<uint256>> const&)
txdb.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long>(unsigned long&&)
Line
Count
Source
491
289k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txdb.cpp:Wrapper<AmountCompression, long const&> Using<AmountCompression, long const&>(long const&)
Line
Count
Source
491
289k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txdb.cpp:Wrapper<ScriptCompression, CScript const&> Using<ScriptCompression, CScript const&>(CScript const&)
Line
Count
Source
491
289k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
txdb.cpp:Wrapper<TxOutCompression, CTxOut const&> Using<TxOutCompression, CTxOut const&>(CTxOut const&)
Line
Count
Source
491
289k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
491
3.98k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
491
2.01k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
491
1.97k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
491
1.91k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> Using<VarIntFormatter<(VarIntMode)0>, unsigned int&>(unsigned int&)
Line
Count
Source
491
8.97k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation.cpp:Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> Using<VarIntFormatter<(VarIntMode)0>, unsigned long&>(unsigned long&)
Line
Count
Source
491
4.48k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation.cpp:Wrapper<AmountCompression, long&> Using<AmountCompression, long&>(long&)
Line
Count
Source
491
4.48k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation.cpp:Wrapper<ScriptCompression, CScript&> Using<ScriptCompression, CScript&>(CScript&)
Line
Count
Source
491
4.48k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
validation.cpp:Wrapper<TxOutCompression, CTxOut&> Using<TxOutCompression, CTxOut&>(CTxOut&)
Line
Count
Source
491
4.48k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: validationinterface.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: validationinterface.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: validationinterface.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: validationinterface.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: coin.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: coin.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: coin.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: coin.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: psbt.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: psbt.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: psbt.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: psbt.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: tx_check.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: tx_check.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: tx_check.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: tx_check.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: interpreter.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: spend.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: spend.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: spend.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: spend.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: wallet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: wallet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: wallet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
wallet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&>(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
Line
Count
Source
491
23.8k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
wallet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
491
18
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
wallet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
491
10
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
wallet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
491
8
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
wallet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>(std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
491
5
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
wallet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&>(std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&)
Line
Count
Source
491
11.4k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
wallet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&>(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
Line
Count
Source
491
11.4k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: wallet.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<unsigned int, std::allocator<unsigned int>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<unsigned int, std::allocator<unsigned int>>&>(std::vector<unsigned int, std::allocator<unsigned int>>&)
Line
Count
Source
491
277
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
walletdb.cpp:Wrapper<CustomUintFormatter<4, true>, unsigned int&> Using<CustomUintFormatter<4, true>, unsigned int&>(unsigned int&)
Line
Count
Source
491
5.67k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>(std::vector<uint256, std::allocator<uint256>>&)
Unexecuted instantiation: walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&>(std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&)
Unexecuted instantiation: walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&>(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
Unexecuted instantiation: walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&>(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
Unexecuted instantiation: walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<unsigned int, std::allocator<unsigned int>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<unsigned int, std::allocator<unsigned int>> const&>(std::vector<unsigned int, std::allocator<unsigned int>> const&)
Unexecuted instantiation: walletdb.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>(std::vector<uint256, std::allocator<uint256>> const&)
walletdb.cpp:Wrapper<CustomUintFormatter<4, true>, unsigned int const&> Using<CustomUintFormatter<4, true>, unsigned int const&>(unsigned int const&)
Line
Count
Source
491
56
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: export.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: export.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: export.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: export.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&>(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
Unexecuted instantiation: export.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: export.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: export.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: export.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>(std::vector<uint256, std::allocator<uint256>>&)
Unexecuted instantiation: export.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&>(std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&)
Unexecuted instantiation: export.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&>(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
Unexecuted instantiation: feebumper.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: feebumper.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: feebumper.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: feebumper.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: backup.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>(std::vector<uint256, std::allocator<uint256>>&)
Unexecuted instantiation: spend.cpp:Wrapper<CustomUintFormatter<4, true>, unsigned int const&> Using<CustomUintFormatter<4, true>, unsigned int const&>(unsigned int const&)
Unexecuted instantiation: transactions.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: transactions.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: transactions.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: transactions.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: protocol.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: protocol.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: protocol.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: protocol.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: process.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: process.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: process.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: process.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: init.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: init.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: init.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: init.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: init.capnp.proxy-types.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: init.capnp.proxy-types.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: init.capnp.proxy-types.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: init.capnp.proxy-types.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: mining.capnp.proxy-types.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: mining.capnp.proxy-types.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: mining.capnp.proxy-types.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: mining.capnp.proxy-types.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: init.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: init.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: init.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: init.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: mining.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: mining.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: mining.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: mining.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: mining.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: mining.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: mining.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: mining.capnp.proxy-client.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Unexecuted instantiation: mining.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: mining.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: mining.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: mining.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Unexecuted instantiation: mining.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: mining.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: mining.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: mining.capnp.proxy-server.c++:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
core_io.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
491
20
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
core_io.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
491
16
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: core_io.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
core_io.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
491
191
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
core_io.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
491
190
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
core_io.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
491
1
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: core_io.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Unexecuted instantiation: core_io.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: external_signer.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: external_signer.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: external_signer.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: external_signer.cpp:Wrapper<CustomUintFormatter<4, true>, unsigned int const&> Using<CustomUintFormatter<4, true>, unsigned int const&>(unsigned int const&)
key_io.cpp:Wrapper<CustomUintFormatter<4, true>, unsigned int&> Using<CustomUintFormatter<4, true>, unsigned int&>(unsigned int&)
Line
Count
Source
491
8.68k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
key_io.cpp:Wrapper<CustomUintFormatter<4, true>, unsigned int const&> Using<CustomUintFormatter<4, true>, unsigned int const&>(unsigned int const&)
Line
Count
Source
491
1.09k
static inline Wrapper<Formatter, T&> Using(T&& t) { return Wrapper<Formatter, T&>(t); }
Unexecuted instantiation: policy.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: policy.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: policy.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: policy.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: psbt.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Unexecuted instantiation: psbt.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Unexecuted instantiation: psbt.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: psbt.cpp:Wrapper<CustomUintFormatter<4, true>, unsigned int&> Using<CustomUintFormatter<4, true>, unsigned int&>(unsigned int&)
Unexecuted instantiation: rawtransaction_util.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: rawtransaction_util.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: rawtransaction_util.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: rawtransaction_util.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: descriptor.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: descriptor.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: descriptor.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: descriptor.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: miniscript.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: miniscript.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: miniscript.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: miniscript.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: sign.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: sign.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: sign.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: sign.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Unexecuted instantiation: bitcoind.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Unexecuted instantiation: bitcoind.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Unexecuted instantiation: bitcoind.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Unexecuted instantiation: bitcoind.cpp:Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&> Using<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>(std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
492
493
402k
#define VARINT_MODE(obj, mode) Using<VarIntFormatter<mode>>(obj)
494
3.13M
#define VARINT(obj) Using<VarIntFormatter<VarIntMode::DEFAULT>>(obj)
495
42.1k
#define COMPACTSIZE(obj) Using<CompactSizeFormatter<true>>(obj)
496
1.76k
#define LIMITED_STRING(obj,n) Using<LimitedStringFormatter<n>>(obj)
497
62
#define LIMITED_VECTOR(obj,n) Using<LimitedVectorFormatter<n>>(obj)
498
499
/** Serialization wrapper class for integers in VarInt format. */
500
template<VarIntMode Mode>
501
struct VarIntFormatter
502
{
503
    template<typename Stream, typename I> void Ser(Stream &s, I v)
504
8.16M
    {
505
8.16M
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
8.16M
    }
void VarIntFormatter<(VarIntMode)1>::Ser<VectorWriter, int>(VectorWriter&, int)
Line
Count
Source
504
25.0k
    {
505
25.0k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
25.0k
    }
void VarIntFormatter<(VarIntMode)0>::Ser<VectorWriter, unsigned long>(VectorWriter&, unsigned long)
Line
Count
Source
504
124k
    {
505
124k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
124k
    }
void VarIntFormatter<(VarIntMode)0>::Ser<DataStream, unsigned long>(DataStream&, unsigned long)
Line
Count
Source
504
293k
    {
505
293k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
293k
    }
void VarIntFormatter<(VarIntMode)1>::Ser<DataStream, int>(DataStream&, int)
Line
Count
Source
504
443k
    {
505
443k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
443k
    }
void VarIntFormatter<(VarIntMode)1>::Ser<SizeComputer, int>(SizeComputer&, int)
Line
Count
Source
504
100k
    {
505
100k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
100k
    }
void VarIntFormatter<(VarIntMode)0>::Ser<SizeComputer, unsigned long>(SizeComputer&, unsigned long)
Line
Count
Source
504
69.6k
    {
505
69.6k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
69.6k
    }
void VarIntFormatter<(VarIntMode)1>::Ser<DataStream, signed char>(DataStream&, signed char)
Line
Count
Source
504
1
    {
505
1
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
1
    }
void VarIntFormatter<(VarIntMode)0>::Ser<DataStream, unsigned char>(DataStream&, unsigned char)
Line
Count
Source
504
1
    {
505
1
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
1
    }
void VarIntFormatter<(VarIntMode)1>::Ser<DataStream, short>(DataStream&, short)
Line
Count
Source
504
1
    {
505
1
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
1
    }
void VarIntFormatter<(VarIntMode)0>::Ser<DataStream, unsigned short>(DataStream&, unsigned short)
Line
Count
Source
504
1
    {
505
1
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
1
    }
void VarIntFormatter<(VarIntMode)0>::Ser<DataStream, unsigned int>(DataStream&, unsigned int)
Line
Count
Source
504
6.56M
    {
505
6.56M
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
6.56M
    }
void VarIntFormatter<(VarIntMode)1>::Ser<DataStream, long long>(DataStream&, long long)
Line
Count
Source
504
1
    {
505
1
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
1
    }
void VarIntFormatter<(VarIntMode)0>::Ser<DataStream, unsigned long long>(DataStream&, unsigned long long)
Line
Count
Source
504
1
    {
505
1
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
1
    }
void VarIntFormatter<(VarIntMode)0>::Ser<SizeComputer, unsigned int>(SizeComputer&, unsigned int)
Line
Count
Source
504
129k
    {
505
129k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
129k
    }
void VarIntFormatter<(VarIntMode)0>::Ser<HashWriter, unsigned int>(HashWriter&, unsigned int)
Line
Count
Source
504
129k
    {
505
129k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
129k
    }
void VarIntFormatter<(VarIntMode)0>::Ser<HashWriter, unsigned long>(HashWriter&, unsigned long)
Line
Count
Source
504
69.5k
    {
505
69.5k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
69.5k
    }
void VarIntFormatter<(VarIntMode)0>::Ser<BufferedWriter<AutoFile>, unsigned int>(BufferedWriter<AutoFile>&, unsigned int)
Line
Count
Source
504
129k
    {
505
129k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
129k
    }
void VarIntFormatter<(VarIntMode)0>::Ser<BufferedWriter<AutoFile>, unsigned long>(BufferedWriter<AutoFile>&, unsigned long)
Line
Count
Source
504
69.5k
    {
505
69.5k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
69.5k
    }
void VarIntFormatter<(VarIntMode)0>::Ser<AutoFile, unsigned int>(AutoFile&, unsigned int)
Line
Count
Source
504
7.05k
    {
505
7.05k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
7.05k
    }
void VarIntFormatter<(VarIntMode)0>::Ser<AutoFile, unsigned long>(AutoFile&, unsigned long)
Line
Count
Source
504
6.58k
    {
505
6.58k
        WriteVarInt<Stream,Mode, std::remove_cv_t<I>>(s, v);
506
6.58k
    }
507
508
    template<typename Stream, typename I> void Unser(Stream& s, I& v)
509
3.15M
    {
510
3.15M
        v = ReadVarInt<Stream,Mode, std::remove_cv_t<I>>(s);
511
3.15M
    }
void VarIntFormatter<(VarIntMode)1>::Unser<SpanReader, int>(SpanReader&, int&)
Line
Count
Source
509
79.0k
    {
510
79.0k
        v = ReadVarInt<Stream,Mode, std::remove_cv_t<I>>(s);
511
79.0k
    }
void VarIntFormatter<(VarIntMode)0>::Unser<SpanReader, unsigned long>(SpanReader&, unsigned long&)
Line
Count
Source
509
466k
    {
510
466k
        v = ReadVarInt<Stream,Mode, std::remove_cv_t<I>>(s);
511
466k
    }
void VarIntFormatter<(VarIntMode)0>::Unser<SpanReader, unsigned int>(SpanReader&, unsigned int&)
Line
Count
Source
509
464k
    {
510
464k
        v = ReadVarInt<Stream,Mode, std::remove_cv_t<I>>(s);
511
464k
    }
void VarIntFormatter<(VarIntMode)1>::Unser<DataStream, int>(DataStream&, int&)
Line
Count
Source
509
558k
    {
510
558k
        v = ReadVarInt<Stream,Mode, std::remove_cv_t<I>>(s);
511
558k
    }
void VarIntFormatter<(VarIntMode)0>::Unser<DataStream, unsigned long>(DataStream&, unsigned long&)
Line
Count
Source
509
279k
    {
510
279k
        v = ReadVarInt<Stream,Mode, std::remove_cv_t<I>>(s);
511
279k
    }
void VarIntFormatter<(VarIntMode)0>::Unser<DataStream, unsigned int>(DataStream&, unsigned int&)
Line
Count
Source
509
1.16M
    {
510
1.16M
        v = ReadVarInt<Stream,Mode, std::remove_cv_t<I>>(s);
511
1.16M
    }
void VarIntFormatter<(VarIntMode)0>::Unser<AutoFile, unsigned int>(AutoFile&, unsigned int&)
Line
Count
Source
509
12.7k
    {
510
12.7k
        v = ReadVarInt<Stream,Mode, std::remove_cv_t<I>>(s);
511
12.7k
    }
void VarIntFormatter<(VarIntMode)0>::Unser<AutoFile, unsigned long>(AutoFile&, unsigned long&)
Line
Count
Source
509
6.35k
    {
510
6.35k
        v = ReadVarInt<Stream,Mode, std::remove_cv_t<I>>(s);
511
6.35k
    }
void VarIntFormatter<(VarIntMode)0>::Unser<HashVerifier<BufferedReader<AutoFile>>, unsigned int>(HashVerifier<BufferedReader<AutoFile>>&, unsigned int&)
Line
Count
Source
509
93.4k
    {
510
93.4k
        v = ReadVarInt<Stream,Mode, std::remove_cv_t<I>>(s);
511
93.4k
    }
void VarIntFormatter<(VarIntMode)0>::Unser<HashVerifier<BufferedReader<AutoFile>>, unsigned long>(HashVerifier<BufferedReader<AutoFile>>&, unsigned long&)
Line
Count
Source
509
31.1k
    {
510
31.1k
        v = ReadVarInt<Stream,Mode, std::remove_cv_t<I>>(s);
511
31.1k
    }
512
};
513
514
/** Serialization wrapper class for custom integers and enums.
515
 *
516
 * It permits specifying the serialized size (1 to 8 bytes) and endianness.
517
 *
518
 * Use the big endian mode for values that are stored in memory in native
519
 * byte order, but serialized in big endian notation. This is only intended
520
 * to implement serializers that are compatible with existing formats, and
521
 * its use is not recommended for new data structures.
522
 */
523
template<int Bytes, bool BigEndian = false>
524
struct CustomUintFormatter
525
{
526
    static_assert(Bytes > 0 && Bytes <= 8, "CustomUintFormatter Bytes out of range");
527
    static constexpr uint64_t MAX = 0xffffffffffffffff >> (8 * (8 - Bytes));
528
529
    template <typename Stream, typename I> void Ser(Stream& s, I v)
530
299k
    {
531
299k
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
299k
        if (BigEndian) {
533
239k
            uint64_t raw = htobe64_internal(v);
534
239k
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
239k
        } else {
536
60.1k
            uint64_t raw = htole64_internal(v);
537
60.1k
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
60.1k
        }
539
299k
    }
void CustomUintFormatter<8, false>::Ser<ParamsStream<DataStream&, CAddress::SerParams>, ServiceFlags>(ParamsStream<DataStream&, CAddress::SerParams>&, ServiceFlags)
Line
Count
Source
530
5
    {
531
5
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
5
        if (BigEndian) {
533
0
            uint64_t raw = htobe64_internal(v);
534
0
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
5
        } else {
536
5
            uint64_t raw = htole64_internal(v);
537
5
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
5
        }
539
5
    }
void CustomUintFormatter<2, true>::Ser<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned short>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned short)
Line
Count
Source
530
23
    {
531
23
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
23
        if (BigEndian) {
533
23
            uint64_t raw = htobe64_internal(v);
534
23
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
23
        } else {
536
0
            uint64_t raw = htole64_internal(v);
537
0
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
0
        }
539
23
    }
void CustomUintFormatter<4, true>::Ser<DataStream, unsigned int>(DataStream&, unsigned int)
Line
Count
Source
530
40
    {
531
40
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
40
        if (BigEndian) {
533
40
            uint64_t raw = htobe64_internal(v);
534
40
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
40
        } else {
536
0
            uint64_t raw = htole64_internal(v);
537
0
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
0
        }
539
40
    }
void CustomUintFormatter<6, false>::Ser<DataStream, unsigned long>(DataStream&, unsigned long)
Line
Count
Source
530
14
    {
531
14
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
14
        if (BigEndian) {
533
0
            uint64_t raw = htobe64_internal(v);
534
0
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
14
        } else {
536
14
            uint64_t raw = htole64_internal(v);
537
14
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
14
        }
539
14
    }
void CustomUintFormatter<2, true>::Ser<ParamsStream<VectorWriter&, CAddress::SerParams>, unsigned short>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned short)
Line
Count
Source
530
1
    {
531
1
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
1
        if (BigEndian) {
533
1
            uint64_t raw = htobe64_internal(v);
534
1
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
1
        } else {
536
0
            uint64_t raw = htole64_internal(v);
537
0
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
0
        }
539
1
    }
void CustomUintFormatter<3, true>::Ser<DataStream, unsigned int>(DataStream&, unsigned int)
Line
Count
Source
530
4.58k
    {
531
4.58k
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
4.58k
        if (BigEndian) {
533
4.58k
            uint64_t raw = htobe64_internal(v);
534
4.58k
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
4.58k
        } else {
536
0
            uint64_t raw = htole64_internal(v);
537
0
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
0
        }
539
4.58k
    }
void CustomUintFormatter<5, true>::Ser<DataStream, unsigned long>(DataStream&, unsigned long)
Line
Count
Source
530
4.57k
    {
531
4.57k
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
4.57k
        if (BigEndian) {
533
4.57k
            uint64_t raw = htobe64_internal(v);
534
4.57k
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
4.57k
        } else {
536
0
            uint64_t raw = htole64_internal(v);
537
0
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
0
        }
539
4.57k
    }
void CustomUintFormatter<4, true>::Ser<SizeComputer, unsigned int>(SizeComputer&, unsigned int)
Line
Count
Source
530
4
    {
531
4
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
4
        if (BigEndian) {
533
4
            uint64_t raw = htobe64_internal(v);
534
4
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
4
        } else {
536
0
            uint64_t raw = htole64_internal(v);
537
0
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
0
        }
539
4
    }
void CustomUintFormatter<8, false>::Ser<VectorWriter, ServiceFlags>(VectorWriter&, ServiceFlags)
Line
Count
Source
530
5
    {
531
5
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
5
        if (BigEndian) {
533
0
            uint64_t raw = htobe64_internal(v);
534
0
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
5
        } else {
536
5
            uint64_t raw = htole64_internal(v);
537
5
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
5
        }
539
5
    }
void CustomUintFormatter<2, true>::Ser<ParamsStream<VectorWriter&, CNetAddr::SerParams>, unsigned short>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, unsigned short)
Line
Count
Source
530
3.48k
    {
531
3.48k
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
3.48k
        if (BigEndian) {
533
3.48k
            uint64_t raw = htobe64_internal(v);
534
3.48k
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
3.48k
        } else {
536
0
            uint64_t raw = htole64_internal(v);
537
0
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
0
        }
539
3.48k
    }
Unexecuted instantiation: void CustomUintFormatter<8, false>::Ser<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, ServiceFlags>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, ServiceFlags)
void CustomUintFormatter<2, true>::Ser<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned short>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned short)
Line
Count
Source
530
50.3k
    {
531
50.3k
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
50.3k
        if (BigEndian) {
533
50.3k
            uint64_t raw = htobe64_internal(v);
534
50.3k
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
50.3k
        } else {
536
0
            uint64_t raw = htole64_internal(v);
537
0
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
0
        }
539
50.3k
    }
void CustomUintFormatter<6, false>::Ser<SizeComputer, unsigned long>(SizeComputer&, unsigned long)
Line
Count
Source
530
27.7k
    {
531
27.7k
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
27.7k
        if (BigEndian) {
533
0
            uint64_t raw = htobe64_internal(v);
534
0
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
27.7k
        } else {
536
27.7k
            uint64_t raw = htole64_internal(v);
537
27.7k
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
27.7k
        }
539
27.7k
    }
void CustomUintFormatter<6, false>::Ser<VectorWriter, unsigned long>(VectorWriter&, unsigned long)
Line
Count
Source
530
13.4k
    {
531
13.4k
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
13.4k
        if (BigEndian) {
533
0
            uint64_t raw = htobe64_internal(v);
534
0
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
13.4k
        } else {
536
13.4k
            uint64_t raw = htole64_internal(v);
537
13.4k
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
13.4k
        }
539
13.4k
    }
void CustomUintFormatter<8, false>::Ser<ParamsStream<VectorWriter&, CAddress::SerParams>, ServiceFlags>(ParamsStream<VectorWriter&, CAddress::SerParams>&, ServiceFlags)
Line
Count
Source
530
18.9k
    {
531
18.9k
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
18.9k
        if (BigEndian) {
533
0
            uint64_t raw = htobe64_internal(v);
534
0
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
18.9k
        } else {
536
18.9k
            uint64_t raw = htole64_internal(v);
537
18.9k
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
18.9k
        }
539
18.9k
    }
void CustomUintFormatter<2, true>::Ser<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned short>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned short)
Line
Count
Source
530
18.9k
    {
531
18.9k
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
18.9k
        if (BigEndian) {
533
18.9k
            uint64_t raw = htobe64_internal(v);
534
18.9k
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
18.9k
        } else {
536
0
            uint64_t raw = htole64_internal(v);
537
0
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
0
        }
539
18.9k
    }
void CustomUintFormatter<4, true>::Ser<VectorWriter, unsigned int>(VectorWriter&, unsigned int)
Line
Count
Source
530
157k
    {
531
157k
        if (v < 0 || v > MAX) throw std::ios_base::failure("CustomUintFormatter value out of range");
532
157k
        if (BigEndian) {
533
157k
            uint64_t raw = htobe64_internal(v);
534
157k
            s.write(std::as_bytes(std::span{&raw, 1}).last(Bytes));
535
157k
        } else {
536
0
            uint64_t raw = htole64_internal(v);
537
0
            s.write(std::as_bytes(std::span{&raw, 1}).first(Bytes));
538
0
        }
539
157k
    }
540
541
    template <typename Stream, typename I> void Unser(Stream& s, I& v)
542
70.9k
    {
543
70.9k
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
70.9k
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
70.9k
        uint64_t raw = 0;
546
70.9k
        if (BigEndian) {
547
45.1k
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
45.1k
            v = static_cast<I>(be64toh_internal(raw));
549
45.1k
        } else {
550
25.8k
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
25.8k
            v = static_cast<I>(le64toh_internal(raw));
552
25.8k
        }
553
70.9k
    }
void CustomUintFormatter<4, true>::Unser<DataStream, unsigned int>(DataStream&, unsigned int&)
Line
Count
Source
542
5.90k
    {
543
5.90k
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
5.90k
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
5.90k
        uint64_t raw = 0;
546
5.90k
        if (BigEndian) {
547
5.90k
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
5.90k
            v = static_cast<I>(be64toh_internal(raw));
549
5.90k
        } else {
550
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
0
            v = static_cast<I>(le64toh_internal(raw));
552
0
        }
553
5.90k
    }
void CustomUintFormatter<6, false>::Unser<DataStream, unsigned long>(DataStream&, unsigned long&)
Line
Count
Source
542
17.5k
    {
543
17.5k
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
17.5k
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
17.5k
        uint64_t raw = 0;
546
17.5k
        if (BigEndian) {
547
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
0
            v = static_cast<I>(be64toh_internal(raw));
549
17.5k
        } else {
550
17.5k
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
17.5k
            v = static_cast<I>(le64toh_internal(raw));
552
17.5k
        }
553
17.5k
    }
void CustomUintFormatter<8, false>::Unser<ParamsStream<SpanReader&, CAddress::SerParams>, ServiceFlags>(ParamsStream<SpanReader&, CAddress::SerParams>&, ServiceFlags&)
Line
Count
Source
542
4
    {
543
4
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
4
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
4
        uint64_t raw = 0;
546
4
        if (BigEndian) {
547
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
0
            v = static_cast<I>(be64toh_internal(raw));
549
4
        } else {
550
4
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
4
            v = static_cast<I>(le64toh_internal(raw));
552
4
        }
553
4
    }
void CustomUintFormatter<2, true>::Unser<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned short>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned short&)
Line
Count
Source
542
7
    {
543
7
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
7
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
7
        uint64_t raw = 0;
546
7
        if (BigEndian) {
547
7
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
7
            v = static_cast<I>(be64toh_internal(raw));
549
7
        } else {
550
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
0
            v = static_cast<I>(le64toh_internal(raw));
552
0
        }
553
7
    }
void CustomUintFormatter<5, true>::Unser<SpanReader, unsigned long>(SpanReader&, unsigned long&)
Line
Count
Source
542
326
    {
543
326
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
326
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
326
        uint64_t raw = 0;
546
326
        if (BigEndian) {
547
326
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
326
            v = static_cast<I>(be64toh_internal(raw));
549
326
        } else {
550
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
0
            v = static_cast<I>(le64toh_internal(raw));
552
0
        }
553
326
    }
void CustomUintFormatter<3, true>::Unser<SpanReader, unsigned int>(SpanReader&, unsigned int&)
Line
Count
Source
542
326
    {
543
326
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
326
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
326
        uint64_t raw = 0;
546
326
        if (BigEndian) {
547
326
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
326
            v = static_cast<I>(be64toh_internal(raw));
549
326
        } else {
550
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
0
            v = static_cast<I>(le64toh_internal(raw));
552
0
        }
553
326
    }
void CustomUintFormatter<3, true>::Unser<DataStream, unsigned int>(DataStream&, unsigned int&)
Line
Count
Source
542
4
    {
543
4
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
4
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
4
        uint64_t raw = 0;
546
4
        if (BigEndian) {
547
4
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
4
            v = static_cast<I>(be64toh_internal(raw));
549
4
        } else {
550
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
0
            v = static_cast<I>(le64toh_internal(raw));
552
0
        }
553
4
    }
void CustomUintFormatter<4, true>::Unser<SpanReader, unsigned int>(SpanReader&, unsigned int&)
Line
Count
Source
542
9.39k
    {
543
9.39k
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
9.39k
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
9.39k
        uint64_t raw = 0;
546
9.39k
        if (BigEndian) {
547
9.39k
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
9.39k
            v = static_cast<I>(be64toh_internal(raw));
549
9.39k
        } else {
550
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
0
            v = static_cast<I>(le64toh_internal(raw));
552
0
        }
553
9.39k
    }
Unexecuted instantiation: void CustomUintFormatter<8, false>::Unser<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, ServiceFlags>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, ServiceFlags&)
void CustomUintFormatter<2, true>::Unser<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned short>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned short&)
Line
Count
Source
542
20.5k
    {
543
20.5k
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
20.5k
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
20.5k
        uint64_t raw = 0;
546
20.5k
        if (BigEndian) {
547
20.5k
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
20.5k
            v = static_cast<I>(be64toh_internal(raw));
549
20.5k
        } else {
550
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
0
            v = static_cast<I>(le64toh_internal(raw));
552
0
        }
553
20.5k
    }
Unexecuted instantiation: void CustomUintFormatter<1, false>::Unser<AutoFile, AddrManImpl::Format>(AutoFile&, AddrManImpl::Format&)
Unexecuted instantiation: void CustomUintFormatter<8, false>::Unser<ParamsStream<AutoFile&, CAddress::SerParams>, ServiceFlags>(ParamsStream<AutoFile&, CAddress::SerParams>&, ServiceFlags&)
Unexecuted instantiation: void CustomUintFormatter<2, true>::Unser<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned short>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned short&)
void CustomUintFormatter<1, false>::Unser<HashVerifier<AutoFile>, AddrManImpl::Format>(HashVerifier<AutoFile>&, AddrManImpl::Format&)
Line
Count
Source
542
639
    {
543
639
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
639
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
639
        uint64_t raw = 0;
546
639
        if (BigEndian) {
547
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
0
            v = static_cast<I>(be64toh_internal(raw));
549
639
        } else {
550
639
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
639
            v = static_cast<I>(le64toh_internal(raw));
552
639
        }
553
639
    }
void CustomUintFormatter<1, false>::Unser<DataStream, AddrManImpl::Format>(DataStream&, AddrManImpl::Format&)
Line
Count
Source
542
7
    {
543
7
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
7
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
7
        uint64_t raw = 0;
546
7
        if (BigEndian) {
547
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
0
            v = static_cast<I>(be64toh_internal(raw));
549
7
        } else {
550
7
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
7
            v = static_cast<I>(le64toh_internal(raw));
552
7
        }
553
7
    }
void CustomUintFormatter<8, false>::Unser<ParamsStream<DataStream&, CAddress::SerParams>, ServiceFlags>(ParamsStream<DataStream&, CAddress::SerParams>&, ServiceFlags&)
Line
Count
Source
542
5.88k
    {
543
5.88k
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
5.88k
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
5.88k
        uint64_t raw = 0;
546
5.88k
        if (BigEndian) {
547
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
0
            v = static_cast<I>(be64toh_internal(raw));
549
5.88k
        } else {
550
5.88k
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
5.88k
            v = static_cast<I>(le64toh_internal(raw));
552
5.88k
        }
553
5.88k
    }
void CustomUintFormatter<2, true>::Unser<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned short>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned short&)
Line
Count
Source
542
6.91k
    {
543
6.91k
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
6.91k
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
6.91k
        uint64_t raw = 0;
546
6.91k
        if (BigEndian) {
547
6.91k
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
6.91k
            v = static_cast<I>(be64toh_internal(raw));
549
6.91k
        } else {
550
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
0
            v = static_cast<I>(le64toh_internal(raw));
552
0
        }
553
6.91k
    }
void CustomUintFormatter<1, false>::Unser<HashVerifier<DataStream>, AddrManImpl::Format>(HashVerifier<DataStream>&, AddrManImpl::Format&)
Line
Count
Source
542
2
    {
543
2
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
2
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
2
        uint64_t raw = 0;
546
2
        if (BigEndian) {
547
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
0
            v = static_cast<I>(be64toh_internal(raw));
549
2
        } else {
550
2
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
2
            v = static_cast<I>(le64toh_internal(raw));
552
2
        }
553
2
    }
void CustomUintFormatter<8, false>::Unser<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, ServiceFlags>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, ServiceFlags&)
Line
Count
Source
542
1
    {
543
1
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
1
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
1
        uint64_t raw = 0;
546
1
        if (BigEndian) {
547
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
0
            v = static_cast<I>(be64toh_internal(raw));
549
1
        } else {
550
1
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
1
            v = static_cast<I>(le64toh_internal(raw));
552
1
        }
553
1
    }
void CustomUintFormatter<2, true>::Unser<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned short>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned short&)
Line
Count
Source
542
4
    {
543
4
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
4
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
4
        uint64_t raw = 0;
546
4
        if (BigEndian) {
547
4
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
4
            v = static_cast<I>(be64toh_internal(raw));
549
4
        } else {
550
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
0
            v = static_cast<I>(le64toh_internal(raw));
552
0
        }
553
4
    }
Unexecuted instantiation: void CustomUintFormatter<2, true>::Unser<ParamsStream<SpanReader, CAddress::SerParams>, unsigned short>(ParamsStream<SpanReader, CAddress::SerParams>&, unsigned short&)
void CustomUintFormatter<8, false>::Unser<DataStream, ServiceFlags>(DataStream&, ServiceFlags&)
Line
Count
Source
542
1.73k
    {
543
1.73k
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
1.73k
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
1.73k
        uint64_t raw = 0;
546
1.73k
        if (BigEndian) {
547
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
0
            v = static_cast<I>(be64toh_internal(raw));
549
1.73k
        } else {
550
1.73k
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
1.73k
            v = static_cast<I>(le64toh_internal(raw));
552
1.73k
        }
553
1.73k
    }
void CustomUintFormatter<2, true>::Unser<ParamsStream<DataStream&, CNetAddr::SerParams>, unsigned short>(ParamsStream<DataStream&, CNetAddr::SerParams>&, unsigned short&)
Line
Count
Source
542
1.73k
    {
543
1.73k
        using U = typename std::conditional_t<std::is_enum_v<I>, std::underlying_type<I>, std::common_type<I>>::type;
544
1.73k
        static_assert(std::numeric_limits<U>::max() >= MAX && std::numeric_limits<U>::min() <= 0, "Assigned type too small");
545
1.73k
        uint64_t raw = 0;
546
1.73k
        if (BigEndian) {
547
1.73k
            s.read(std::as_writable_bytes(std::span{&raw, 1}).last(Bytes));
548
1.73k
            v = static_cast<I>(be64toh_internal(raw));
549
1.73k
        } else {
550
0
            s.read(std::as_writable_bytes(std::span{&raw, 1}).first(Bytes));
551
0
            v = static_cast<I>(le64toh_internal(raw));
552
0
        }
553
1.73k
    }
554
};
555
556
template<int Bytes> using BigEndianFormatter = CustomUintFormatter<Bytes, true>;
557
558
/** Formatter for integers in CompactSize format. */
559
template<bool RangeCheck>
560
struct CompactSizeFormatter
561
{
562
    template<typename Stream, typename I>
563
    void Unser(Stream& s, I& v)
564
85.3k
    {
565
85.3k
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
85.3k
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
85.3k
        v = n;
570
85.3k
    }
void CompactSizeFormatter<true>::Unser<DataStream, unsigned short>(DataStream&, unsigned short&)
Line
Count
Source
564
21.6k
    {
565
21.6k
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
21.6k
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
21.6k
        v = n;
570
21.6k
    }
void CompactSizeFormatter<true>::Unser<ParamsStream<DataStream&, CAddress::SerParams>, unsigned long>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned long&)
Line
Count
Source
564
32
    {
565
32
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
32
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
32
        v = n;
570
32
    }
void CompactSizeFormatter<false>::Unser<ParamsStream<SpanReader&, CAddress::SerParams>, unsigned long>(ParamsStream<SpanReader&, CAddress::SerParams>&, unsigned long&)
Line
Count
Source
564
3
    {
565
3
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
3
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
3
        v = n;
570
3
    }
void CompactSizeFormatter<true>::Unser<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned long>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long&)
Line
Count
Source
564
3
    {
565
3
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
3
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
3
        v = n;
570
3
    }
void CompactSizeFormatter<false>::Unser<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, unsigned long>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, unsigned long&)
Line
Count
Source
564
20.5k
    {
565
20.5k
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
20.5k
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
20.5k
        v = n;
570
20.5k
    }
void CompactSizeFormatter<true>::Unser<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned long>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long&)
Line
Count
Source
564
20.5k
    {
565
20.5k
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
20.5k
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
20.5k
        v = n;
570
20.5k
    }
Unexecuted instantiation: void CompactSizeFormatter<false>::Unser<ParamsStream<AutoFile&, CAddress::SerParams>, unsigned long>(ParamsStream<AutoFile&, CAddress::SerParams>&, unsigned long&)
Unexecuted instantiation: void CompactSizeFormatter<true>::Unser<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned long>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long&)
Unexecuted instantiation: void CompactSizeFormatter<true>::Unser<ParamsStream<AutoFile&, CAddress::SerParams>, unsigned long>(ParamsStream<AutoFile&, CAddress::SerParams>&, unsigned long&)
void CompactSizeFormatter<true>::Unser<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, unsigned long>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, unsigned long&)
Line
Count
Source
564
20.5k
    {
565
20.5k
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
20.5k
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
20.5k
        v = n;
570
20.5k
    }
void CompactSizeFormatter<false>::Unser<ParamsStream<DataStream&, CAddress::SerParams>, unsigned long>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned long&)
Line
Count
Source
564
1.03k
    {
565
1.03k
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
1.03k
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
1.03k
        v = n;
570
1.03k
    }
void CompactSizeFormatter<true>::Unser<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned long>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long&)
Line
Count
Source
564
1.03k
    {
565
1.03k
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
1.03k
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
1.03k
        v = n;
570
1.03k
    }
void CompactSizeFormatter<false>::Unser<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, unsigned long>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, unsigned long&)
Line
Count
Source
564
3
    {
565
3
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
3
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
3
        v = n;
570
3
    }
void CompactSizeFormatter<true>::Unser<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned long>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long&)
Line
Count
Source
564
3
    {
565
3
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
3
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
3
        v = n;
570
3
    }
void CompactSizeFormatter<true>::Unser<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, unsigned long>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, unsigned long&)
Line
Count
Source
564
3
    {
565
3
        uint64_t n = ReadCompactSize<Stream>(s, RangeCheck);
566
3
        if (n < std::numeric_limits<I>::min() || n > std::numeric_limits<I>::max()) {
567
0
            throw std::ios_base::failure("CompactSize exceeds limit of type");
568
0
        }
569
3
        v = n;
570
3
    }
Unexecuted instantiation: void CompactSizeFormatter<true>::Unser<ParamsStream<SpanReader, CAddress::SerParams>, unsigned long>(ParamsStream<SpanReader, CAddress::SerParams>&, unsigned long&)
Unexecuted instantiation: void CompactSizeFormatter<true>::Unser<ParamsStream<DataStream&, CNetAddr::SerParams>, unsigned long>(ParamsStream<DataStream&, CNetAddr::SerParams>&, unsigned long&)
571
572
    template<typename Stream, typename I>
573
    void Ser(Stream& s, I v)
574
104k
    {
575
104k
        static_assert(std::is_unsigned_v<I>, "CompactSize only supported for unsigned integers");
576
104k
        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(), "CompactSize only supports 64-bit integers and below");
577
578
104k
        WriteCompactSize<Stream>(s, v);
579
104k
    }
void CompactSizeFormatter<false>::Ser<ParamsStream<DataStream&, CAddress::SerParams>, unsigned long>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned long)
Line
Count
Source
574
18
    {
575
18
        static_assert(std::is_unsigned_v<I>, "CompactSize only supported for unsigned integers");
576
18
        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(), "CompactSize only supports 64-bit integers and below");
577
578
18
        WriteCompactSize<Stream>(s, v);
579
18
    }
Unexecuted instantiation: void CompactSizeFormatter<true>::Ser<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned long>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long)
void CompactSizeFormatter<true>::Ser<ParamsStream<DataStream&, CAddress::SerParams>, unsigned long>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned long)
Line
Count
Source
574
1
    {
575
1
        static_assert(std::is_unsigned_v<I>, "CompactSize only supported for unsigned integers");
576
1
        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(), "CompactSize only supports 64-bit integers and below");
577
578
1
        WriteCompactSize<Stream>(s, v);
579
1
    }
void CompactSizeFormatter<true>::Ser<DataStream, unsigned short>(DataStream&, unsigned short)
Line
Count
Source
574
11
    {
575
11
        static_assert(std::is_unsigned_v<I>, "CompactSize only supported for unsigned integers");
576
11
        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(), "CompactSize only supports 64-bit integers and below");
577
578
11
        WriteCompactSize<Stream>(s, v);
579
11
    }
Unexecuted instantiation: void CompactSizeFormatter<true>::Ser<ParamsStream<VectorWriter&, CAddress::SerParams>, unsigned long>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned long)
Unexecuted instantiation: void CompactSizeFormatter<true>::Ser<ParamsStream<VectorWriter&, CNetAddr::SerParams>, unsigned long>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, unsigned long)
void CompactSizeFormatter<false>::Ser<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, unsigned long>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, unsigned long)
Line
Count
Source
574
50.3k
    {
575
50.3k
        static_assert(std::is_unsigned_v<I>, "CompactSize only supported for unsigned integers");
576
50.3k
        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(), "CompactSize only supports 64-bit integers and below");
577
578
50.3k
        WriteCompactSize<Stream>(s, v);
579
50.3k
    }
Unexecuted instantiation: void CompactSizeFormatter<true>::Ser<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned long>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long)
Unexecuted instantiation: void CompactSizeFormatter<true>::Ser<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, unsigned long>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, unsigned long)
void CompactSizeFormatter<true>::Ser<SizeComputer, unsigned short>(SizeComputer&, unsigned short)
Line
Count
Source
574
35.7k
    {
575
35.7k
        static_assert(std::is_unsigned_v<I>, "CompactSize only supported for unsigned integers");
576
35.7k
        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(), "CompactSize only supports 64-bit integers and below");
577
578
35.7k
        WriteCompactSize<Stream>(s, v);
579
35.7k
    }
void CompactSizeFormatter<true>::Ser<VectorWriter, unsigned short>(VectorWriter&, unsigned short)
Line
Count
Source
574
18.8k
    {
575
18.8k
        static_assert(std::is_unsigned_v<I>, "CompactSize only supported for unsigned integers");
576
18.8k
        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(), "CompactSize only supports 64-bit integers and below");
577
578
18.8k
        WriteCompactSize<Stream>(s, v);
579
18.8k
    }
void CompactSizeFormatter<false>::Ser<ParamsStream<VectorWriter&, CAddress::SerParams>, unsigned long>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned long)
Line
Count
Source
574
33
    {
575
33
        static_assert(std::is_unsigned_v<I>, "CompactSize only supported for unsigned integers");
576
33
        static_assert(std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(), "CompactSize only supports 64-bit integers and below");
577
578
33
        WriteCompactSize<Stream>(s, v);
579
33
    }
Unexecuted instantiation: void CompactSizeFormatter<true>::Ser<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>, unsigned long>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, unsigned long)
580
};
581
582
template <typename U, bool LOSSY = false>
583
struct ChronoFormatter {
584
    template <typename Stream, typename Tp>
585
    void Unser(Stream& s, Tp& tp)
586
48.0k
    {
587
48.0k
        U u;
588
48.0k
        s >> u;
589
        // Lossy deserialization does not make sense, so force Wnarrowing
590
48.0k
        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
591
48.0k
    }
void ChronoFormatter<unsigned int, true>::Unser<ParamsStream<SpanReader&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<SpanReader&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
586
7
    {
587
7
        U u;
588
7
        s >> u;
589
        // Lossy deserialization does not make sense, so force Wnarrowing
590
7
        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
591
7
    }
void ChronoFormatter<unsigned int, true>::Unser<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
586
20.5k
    {
587
20.5k
        U u;
588
20.5k
        s >> u;
589
        // Lossy deserialization does not make sense, so force Wnarrowing
590
20.5k
        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
591
20.5k
    }
Unexecuted instantiation: void ChronoFormatter<unsigned int, true>::Unser<ParamsStream<AutoFile&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<AutoFile&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Unexecuted instantiation: void ChronoFormatter<long, false>::Unser<ParamsStream<AutoFile&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<AutoFile&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
void ChronoFormatter<long, false>::Unser<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
586
20.5k
    {
587
20.5k
        U u;
588
20.5k
        s >> u;
589
        // Lossy deserialization does not make sense, so force Wnarrowing
590
20.5k
        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
591
20.5k
    }
void ChronoFormatter<unsigned int, true>::Unser<ParamsStream<DataStream&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<DataStream&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
586
6.91k
    {
587
6.91k
        U u;
588
6.91k
        s >> u;
589
        // Lossy deserialization does not make sense, so force Wnarrowing
590
6.91k
        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
591
6.91k
    }
void ChronoFormatter<long, false>::Unser<ParamsStream<DataStream&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<DataStream&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
586
13
    {
587
13
        U u;
588
13
        s >> u;
589
        // Lossy deserialization does not make sense, so force Wnarrowing
590
13
        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
591
13
    }
void ChronoFormatter<unsigned int, true>::Unser<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
586
4
    {
587
4
        U u;
588
4
        s >> u;
589
        // Lossy deserialization does not make sense, so force Wnarrowing
590
4
        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
591
4
    }
void ChronoFormatter<long, false>::Unser<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&)
Line
Count
Source
586
4
    {
587
4
        U u;
588
4
        s >> u;
589
        // Lossy deserialization does not make sense, so force Wnarrowing
590
4
        tp = Tp{typename Tp::duration{typename Tp::duration::rep{u}}};
591
4
    }
592
    template <typename Stream, typename Tp>
593
    void Ser(Stream& s, Tp tp)
594
119k
    {
595
119k
        if constexpr (LOSSY) {
596
69.3k
            s << U(tp.time_since_epoch().count());
597
69.3k
        } else {
598
50.3k
            s << U{tp.time_since_epoch().count()};
599
50.3k
        }
600
119k
    }
void ChronoFormatter<unsigned int, true>::Ser<ParamsStream<DataStream&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<DataStream&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>)
Line
Count
Source
594
23
    {
595
23
        if constexpr (LOSSY) {
596
23
            s << U(tp.time_since_epoch().count());
597
        } else {
598
            s << U{tp.time_since_epoch().count()};
599
        }
600
23
    }
void ChronoFormatter<long, false>::Ser<ParamsStream<DataStream&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<DataStream&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>)
Line
Count
Source
594
17
    {
595
        if constexpr (LOSSY) {
596
            s << U(tp.time_since_epoch().count());
597
17
        } else {
598
17
            s << U{tp.time_since_epoch().count()};
599
17
        }
600
17
    }
void ChronoFormatter<unsigned int, true>::Ser<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>)
Line
Count
Source
594
50.3k
    {
595
50.3k
        if constexpr (LOSSY) {
596
50.3k
            s << U(tp.time_since_epoch().count());
597
        } else {
598
            s << U{tp.time_since_epoch().count()};
599
        }
600
50.3k
    }
void ChronoFormatter<long, false>::Ser<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>)
Line
Count
Source
594
50.3k
    {
595
        if constexpr (LOSSY) {
596
            s << U(tp.time_since_epoch().count());
597
50.3k
        } else {
598
50.3k
            s << U{tp.time_since_epoch().count()};
599
50.3k
        }
600
50.3k
    }
void ChronoFormatter<unsigned int, true>::Ser<ParamsStream<VectorWriter&, CAddress::SerParams>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>)
Line
Count
Source
594
18.9k
    {
595
18.9k
        if constexpr (LOSSY) {
596
18.9k
            s << U(tp.time_since_epoch().count());
597
        } else {
598
            s << U{tp.time_since_epoch().count()};
599
        }
600
18.9k
    }
601
};
602
template <typename U>
603
using LossyChronoFormatter = ChronoFormatter<U, true>;
604
605
class CompactSizeReader
606
{
607
protected:
608
    uint64_t& n;
609
public:
610
3.30k
    explicit CompactSizeReader(uint64_t& n_in) : n(n_in) {}
611
612
    template<typename Stream>
613
3.30k
    void Unserialize(Stream &s) const {
614
3.30k
        n = ReadCompactSize<Stream>(s);
615
3.30k
    }
Unexecuted instantiation: void CompactSizeReader::Unserialize<DataStream>(DataStream&) const
void CompactSizeReader::Unserialize<SpanReader>(SpanReader&) const
Line
Count
Source
613
3.30k
    void Unserialize(Stream &s) const {
614
3.30k
        n = ReadCompactSize<Stream>(s);
615
3.30k
    }
616
};
617
618
class CompactSizeWriter
619
{
620
protected:
621
    uint64_t n;
622
public:
623
189k
    explicit CompactSizeWriter(uint64_t n_in) : n(n_in) { }
624
625
    template<typename Stream>
626
209k
    void Serialize(Stream &s) const {
627
209k
        WriteCompactSize<Stream>(s, n);
628
209k
    }
void CompactSizeWriter::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
626
22.5k
    void Serialize(Stream &s) const {
627
22.5k
        WriteCompactSize<Stream>(s, n);
628
22.5k
    }
void CompactSizeWriter::Serialize<DataStream>(DataStream&) const
Line
Count
Source
626
22.5k
    void Serialize(Stream &s) const {
627
22.5k
        WriteCompactSize<Stream>(s, n);
628
22.5k
    }
void CompactSizeWriter::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
626
163k
    void Serialize(Stream &s) const {
627
163k
        WriteCompactSize<Stream>(s, n);
628
163k
    }
629
};
630
631
template<size_t Limit>
632
struct LimitedStringFormatter
633
{
634
    template<typename Stream>
635
    void Unser(Stream& s, std::string& v)
636
1.76k
    {
637
1.76k
        size_t size = ReadCompactSize(s);
638
1.76k
        if (size > Limit) {
639
2
            throw std::ios_base::failure("String length limit exceeded");
640
2
        }
641
1.76k
        v.resize(size);
642
1.76k
        if (size != 0) s.read(MakeWritableByteSpan(v));
643
1.76k
    }
void LimitedStringFormatter<256ul>::Unser<AutoFile>(AutoFile&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
636
4
    {
637
4
        size_t size = ReadCompactSize(s);
638
4
        if (size > Limit) {
639
0
            throw std::ios_base::failure("String length limit exceeded");
640
0
        }
641
4
        v.resize(size);
642
4
        if (size != 0) s.read(MakeWritableByteSpan(v));
643
4
    }
void LimitedStringFormatter<256ul>::Unser<DataStream>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
636
1.70k
    {
637
1.70k
        size_t size = ReadCompactSize(s);
638
1.70k
        if (size > Limit) {
639
0
            throw std::ios_base::failure("String length limit exceeded");
640
0
        }
641
1.70k
        v.resize(size);
642
1.70k
        if (size != 0) s.read(MakeWritableByteSpan(v));
643
1.70k
    }
void LimitedStringFormatter<80ul>::Unser<DataStream>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
636
56
    {
637
56
        size_t size = ReadCompactSize(s);
638
56
        if (size > Limit) {
639
2
            throw std::ios_base::failure("String length limit exceeded");
640
2
        }
641
54
        v.resize(size);
642
54
        if (size != 0) s.read(MakeWritableByteSpan(v));
643
54
    }
644
645
    template<typename Stream>
646
    void Ser(Stream& s, const std::string& v)
647
3
    {
648
3
        s << v;
649
3
    }
650
};
651
652
/** Formatter to serialize/deserialize vector elements using another formatter
653
 *
654
 * Example:
655
 *   struct X {
656
 *     std::vector<uint64_t> v;
657
 *     SERIALIZE_METHODS(X, obj) { READWRITE(Using<VectorFormatter<VarInt>>(obj.v)); }
658
 *   };
659
 * will define a struct that contains a vector of uint64_t, which is serialized
660
 * as a vector of VarInt-encoded integers.
661
 *
662
 * V is not required to be an std::vector type. It works for any class that
663
 * exposes a value_type, size, reserve, emplace_back, back, and const iterators.
664
 */
665
template<class Formatter>
666
struct VectorFormatter
667
{
668
    template<typename Stream, typename V>
669
    void Ser(Stream& s, const V& v)
670
18.4M
    {
671
18.4M
        Formatter formatter;
672
18.4M
        WriteCompactSize(s, v.size());
673
78.5M
        for (const typename V::value_type& elem : v) {
674
78.5M
            formatter.Ser(s, elem);
675
78.5M
        }
676
18.4M
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<SizeComputer&, TransactionSerParams>, std::vector<CTxIn, std::allocator<CTxIn>>>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
670
4.44M
    {
671
4.44M
        Formatter formatter;
672
4.44M
        WriteCompactSize(s, v.size());
673
4.46M
        for (const typename V::value_type& elem : v) {
674
4.46M
            formatter.Ser(s, elem);
675
4.46M
        }
676
4.44M
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<SizeComputer&, TransactionSerParams>, std::vector<CTxOut, std::allocator<CTxOut>>>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
670
3.71M
    {
671
3.71M
        Formatter formatter;
672
3.71M
        WriteCompactSize(s, v.size());
673
7.16M
        for (const typename V::value_type& elem : v) {
674
7.16M
            formatter.Ser(s, elem);
675
7.16M
        }
676
3.71M
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<SizeComputer&, TransactionSerParams>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
670
954k
    {
671
954k
        Formatter formatter;
672
954k
        WriteCompactSize(s, v.size());
673
4.52M
        for (const typename V::value_type& elem : v) {
674
4.52M
            formatter.Ser(s, elem);
675
4.52M
        }
676
954k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<SizeComputer&, TransactionSerParams>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
670
710k
    {
671
710k
        Formatter formatter;
672
710k
        WriteCompactSize(s, v.size());
673
1.09M
        for (const typename V::value_type& elem : v) {
674
1.09M
            formatter.Ser(s, elem);
675
1.09M
        }
676
710k
    }
void VectorFormatter<DefaultFormatter>::Ser<SizeComputer, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(SizeComputer&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
670
116k
    {
671
116k
        Formatter formatter;
672
116k
        WriteCompactSize(s, v.size());
673
1.33M
        for (const typename V::value_type& elem : v) {
674
1.33M
            formatter.Ser(s, elem);
675
1.33M
        }
676
116k
    }
void VectorFormatter<CustomUintFormatter<6, false>>::Ser<DataStream, std::vector<unsigned long, std::allocator<unsigned long>>>(DataStream&, std::vector<unsigned long, std::allocator<unsigned long>> const&)
Line
Count
Source
670
9
    {
671
9
        Formatter formatter;
672
9
        WriteCompactSize(s, v.size());
673
14
        for (const typename V::value_type& elem : v) {
674
14
            formatter.Ser(s, elem);
675
14
        }
676
9
    }
void VectorFormatter<DefaultFormatter>::Ser<DataStream, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>>(DataStream&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
670
9
    {
671
9
        Formatter formatter;
672
9
        WriteCompactSize(s, v.size());
673
11
        for (const typename V::value_type& elem : v) {
674
11
            formatter.Ser(s, elem);
675
11
        }
676
9
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<DataStream&, TransactionSerParams>, std::vector<CTxIn, std::allocator<CTxIn>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
670
196k
    {
671
196k
        Formatter formatter;
672
196k
        WriteCompactSize(s, v.size());
673
196k
        for (const typename V::value_type& elem : v) {
674
125k
            formatter.Ser(s, elem);
675
125k
        }
676
196k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<DataStream&, TransactionSerParams>, std::vector<CTxOut, std::allocator<CTxOut>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
670
101k
    {
671
101k
        Formatter formatter;
672
101k
        WriteCompactSize(s, v.size());
673
267k
        for (const typename V::value_type& elem : v) {
674
267k
            formatter.Ser(s, elem);
675
267k
        }
676
101k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<DataStream&, TransactionSerParams>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
670
116k
    {
671
116k
        Formatter formatter;
672
116k
        WriteCompactSize(s, v.size());
673
288k
        for (const typename V::value_type& elem : v) {
674
288k
            formatter.Ser(s, elem);
675
288k
        }
676
116k
    }
void VectorFormatter<DifferenceFormatter>::Ser<DataStream, std::vector<unsigned short, std::allocator<unsigned short>>>(DataStream&, std::vector<unsigned short, std::allocator<unsigned short>> const&)
Line
Count
Source
670
2
    {
671
2
        Formatter formatter;
672
2
        WriteCompactSize(s, v.size());
673
5
        for (const typename V::value_type& elem : v) {
674
5
            formatter.Ser(s, elem);
675
5
        }
676
2
    }
void VectorFormatter<DefaultFormatter>::Ser<DataStream, std::vector<uint256, std::allocator<uint256>>>(DataStream&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
670
29.9k
    {
671
29.9k
        Formatter formatter;
672
29.9k
        WriteCompactSize(s, v.size());
673
273k
        for (const typename V::value_type& elem : v) {
674
273k
            formatter.Ser(s, elem);
675
273k
        }
676
29.9k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<VectorWriter&, TransactionSerParams>, std::vector<CTxIn, std::allocator<CTxIn>>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
670
92.2k
    {
671
92.2k
        Formatter formatter;
672
92.2k
        WriteCompactSize(s, v.size());
673
92.2k
        for (const typename V::value_type& elem : v) {
674
69.5k
            formatter.Ser(s, elem);
675
69.5k
        }
676
92.2k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<VectorWriter&, TransactionSerParams>, std::vector<CTxOut, std::allocator<CTxOut>>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
670
59.3k
    {
671
59.3k
        Formatter formatter;
672
59.3k
        WriteCompactSize(s, v.size());
673
170k
        for (const typename V::value_type& elem : v) {
674
170k
            formatter.Ser(s, elem);
675
170k
        }
676
59.3k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<VectorWriter&, TransactionSerParams>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
670
42.0k
    {
671
42.0k
        Formatter formatter;
672
42.0k
        WriteCompactSize(s, v.size());
673
84.3k
        for (const typename V::value_type& elem : v) {
674
84.3k
            formatter.Ser(s, elem);
675
84.3k
        }
676
42.0k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<HashWriter&, TransactionSerParams>, std::vector<CTxIn, std::allocator<CTxIn>>>(ParamsStream<HashWriter&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
670
2.81M
    {
671
2.81M
        Formatter formatter;
672
2.81M
        WriteCompactSize(s, v.size());
673
2.81M
        for (const typename V::value_type& elem : v) {
674
2.10M
            formatter.Ser(s, elem);
675
2.10M
        }
676
2.81M
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<HashWriter&, TransactionSerParams>, std::vector<CTxOut, std::allocator<CTxOut>>>(ParamsStream<HashWriter&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
670
2.41M
    {
671
2.41M
        Formatter formatter;
672
2.41M
        WriteCompactSize(s, v.size());
673
3.83M
        for (const typename V::value_type& elem : v) {
674
3.83M
            formatter.Ser(s, elem);
675
3.83M
        }
676
2.41M
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<HashWriter&, TransactionSerParams>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(ParamsStream<HashWriter&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
670
556k
    {
671
556k
        Formatter formatter;
672
556k
        WriteCompactSize(s, v.size());
673
3.10M
        for (const typename V::value_type& elem : v) {
674
3.10M
            formatter.Ser(s, elem);
675
3.10M
        }
676
556k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<DataStream&, CAddress::SerParams>, std::vector<CAddress, std::allocator<CAddress>>>(ParamsStream<DataStream&, CAddress::SerParams>&, std::vector<CAddress, std::allocator<CAddress>> const&)
Line
Count
Source
670
2
    {
671
2
        Formatter formatter;
672
2
        WriteCompactSize(s, v.size());
673
6
        for (const typename V::value_type& elem : v) {
674
6
            formatter.Ser(s, elem);
675
6
        }
676
2
    }
void VectorFormatter<DefaultFormatter>::Ser<DataStream, std::vector<int, std::allocator<int>>>(DataStream&, std::vector<int, std::allocator<int>> const&)
Line
Count
Source
670
265k
    {
671
265k
        Formatter formatter;
672
265k
        WriteCompactSize(s, v.size());
673
2.03M
        for (const typename V::value_type& elem : v) {
674
2.03M
            formatter.Ser(s, elem);
675
2.03M
        }
676
265k
    }
void VectorFormatter<DefaultFormatter>::Ser<DataStream, prevector<8u, int, unsigned int, int>>(DataStream&, prevector<8u, int, unsigned int, int> const&)
Line
Count
Source
670
265k
    {
671
265k
        Formatter formatter;
672
265k
        WriteCompactSize(s, v.size());
673
2.03M
        for (const typename V::value_type& elem : v) {
674
2.03M
            formatter.Ser(s, elem);
675
2.03M
        }
676
265k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<DataStream&, serialize_tests::BaseFormat>, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>> const&)
Line
Count
Source
670
2
    {
671
2
        Formatter formatter;
672
2
        WriteCompactSize(s, v.size());
673
4
        for (const typename V::value_type& elem : v) {
674
4
            formatter.Ser(s, elem);
675
4
        }
676
2
    }
void VectorFormatter<DefaultFormatter>::Ser<DataStream, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(DataStream&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
670
270
    {
671
270
        Formatter formatter;
672
270
        WriteCompactSize(s, v.size());
673
575
        for (const typename V::value_type& elem : v) {
674
575
            formatter.Ser(s, elem);
675
575
        }
676
270
    }
void VectorFormatter<DefaultFormatter>::Ser<DataStream, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(DataStream&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
Line
Count
Source
670
24.7k
    {
671
24.7k
        Formatter formatter;
672
24.7k
        WriteCompactSize(s, v.size());
673
24.7k
        for (const typename V::value_type& elem : v) {
674
0
            formatter.Ser(s, elem);
675
0
        }
676
24.7k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, std::vector<CAddress, std::allocator<CAddress>>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, std::vector<CAddress, std::allocator<CAddress>> const&)
Line
Count
Source
670
39
    {
671
39
        Formatter formatter;
672
39
        WriteCompactSize(s, v.size());
673
39
        for (const typename V::value_type& elem : v) {
674
6
            formatter.Ser(s, elem);
675
6
        }
676
39
    }
void VectorFormatter<CustomUintFormatter<6, false>>::Ser<SizeComputer, std::vector<unsigned long, std::allocator<unsigned long>>>(SizeComputer&, std::vector<unsigned long, std::allocator<unsigned long>> const&)
Line
Count
Source
670
35.6k
    {
671
35.6k
        Formatter formatter;
672
35.6k
        WriteCompactSize(s, v.size());
673
35.6k
        for (const typename V::value_type& elem : v) {
674
27.7k
            formatter.Ser(s, elem);
675
27.7k
        }
676
35.6k
    }
void VectorFormatter<DefaultFormatter>::Ser<SizeComputer, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>>(SizeComputer&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
670
35.6k
    {
671
35.6k
        Formatter formatter;
672
35.6k
        WriteCompactSize(s, v.size());
673
35.7k
        for (const typename V::value_type& elem : v) {
674
35.7k
            formatter.Ser(s, elem);
675
35.7k
        }
676
35.6k
    }
void VectorFormatter<CustomUintFormatter<6, false>>::Ser<VectorWriter, std::vector<unsigned long, std::allocator<unsigned long>>>(VectorWriter&, std::vector<unsigned long, std::allocator<unsigned long>> const&)
Line
Count
Source
670
18.8k
    {
671
18.8k
        Formatter formatter;
672
18.8k
        WriteCompactSize(s, v.size());
673
18.8k
        for (const typename V::value_type& elem : v) {
674
13.4k
            formatter.Ser(s, elem);
675
13.4k
        }
676
18.8k
    }
void VectorFormatter<DefaultFormatter>::Ser<VectorWriter, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>>(VectorWriter&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
670
18.8k
    {
671
18.8k
        Formatter formatter;
672
18.8k
        WriteCompactSize(s, v.size());
673
18.8k
        for (const typename V::value_type& elem : v) {
674
18.8k
            formatter.Ser(s, elem);
675
18.8k
        }
676
18.8k
    }
void VectorFormatter<DefaultFormatter>::Ser<VectorWriter, std::vector<CInv, std::allocator<CInv>>>(VectorWriter&, std::vector<CInv, std::allocator<CInv>> const&)
Line
Count
Source
670
58.7k
    {
671
58.7k
        Formatter formatter;
672
58.7k
        WriteCompactSize(s, v.size());
673
84.8k
        for (const typename V::value_type& elem : v) {
674
84.8k
            formatter.Ser(s, elem);
675
84.8k
        }
676
58.7k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<VectorWriter&, TransactionSerParams>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
670
35.6k
    {
671
35.6k
        Formatter formatter;
672
35.6k
        WriteCompactSize(s, v.size());
673
35.6k
        for (const typename V::value_type& elem : v) {
674
26.5k
            formatter.Ser(s, elem);
675
26.5k
        }
676
35.6k
    }
void VectorFormatter<DefaultFormatter>::Ser<VectorWriter, std::vector<uint256, std::allocator<uint256>>>(VectorWriter&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
670
3.01k
    {
671
3.01k
        Formatter formatter;
672
3.01k
        WriteCompactSize(s, v.size());
673
43.4k
        for (const typename V::value_type& elem : v) {
674
43.4k
            formatter.Ser(s, elem);
675
43.4k
        }
676
3.01k
    }
void VectorFormatter<DefaultFormatter>::Ser<VectorWriter, std::vector<CBlockHeader, std::allocator<CBlockHeader>>>(VectorWriter&, std::vector<CBlockHeader, std::allocator<CBlockHeader>> const&)
Line
Count
Source
670
9
    {
671
9
        Formatter formatter;
672
9
        WriteCompactSize(s, v.size());
673
9
        for (const typename V::value_type& elem : v) {
674
0
            formatter.Ser(s, elem);
675
0
        }
676
9
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<VectorWriter&, TransactionSerParams>, std::vector<CBlock, std::allocator<CBlock>>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::vector<CBlock, std::allocator<CBlock>> const&)
Line
Count
Source
670
5.27k
    {
671
5.27k
        Formatter formatter;
672
5.27k
        WriteCompactSize(s, v.size());
673
26.8k
        for (const typename V::value_type& elem : v) {
674
26.8k
            formatter.Ser(s, elem);
675
26.8k
        }
676
5.27k
    }
void VectorFormatter<DifferenceFormatter>::Ser<VectorWriter, std::vector<unsigned short, std::allocator<unsigned short>>>(VectorWriter&, std::vector<unsigned short, std::allocator<unsigned short>> const&)
Line
Count
Source
670
577
    {
671
577
        Formatter formatter;
672
577
        WriteCompactSize(s, v.size());
673
1.47k
        for (const typename V::value_type& elem : v) {
674
1.47k
            formatter.Ser(s, elem);
675
1.47k
        }
676
577
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<VectorWriter&, CAddress::SerParams>, std::vector<CAddress, std::allocator<CAddress>>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, std::vector<CAddress, std::allocator<CAddress>> const&)
Line
Count
Source
670
134
    {
671
134
        Formatter formatter;
672
134
        WriteCompactSize(s, v.size());
673
18.9k
        for (const typename V::value_type& elem : v) {
674
18.9k
            formatter.Ser(s, elem);
675
18.9k
        }
676
134
    }
void VectorFormatter<DefaultFormatter>::Ser<SizeComputer, std::vector<CTxUndo, std::allocator<CTxUndo>>>(SizeComputer&, std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
670
100k
    {
671
100k
        Formatter formatter;
672
100k
        WriteCompactSize(s, v.size());
673
100k
        for (const typename V::value_type& elem : v) {
674
45.0k
            formatter.Ser(s, elem);
675
45.0k
        }
676
100k
    }
void VectorFormatter<TxInUndoFormatter>::Ser<SizeComputer, std::vector<Coin, std::allocator<Coin>>>(SizeComputer&, std::vector<Coin, std::allocator<Coin>> const&)
Line
Count
Source
670
45.0k
    {
671
45.0k
        Formatter formatter;
672
45.0k
        WriteCompactSize(s, v.size());
673
69.5k
        for (const typename V::value_type& elem : v) {
674
69.5k
            formatter.Ser(s, elem);
675
69.5k
        }
676
45.0k
    }
void VectorFormatter<DefaultFormatter>::Ser<HashWriter, std::vector<CTxUndo, std::allocator<CTxUndo>>>(HashWriter&, std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
670
100k
    {
671
100k
        Formatter formatter;
672
100k
        WriteCompactSize(s, v.size());
673
100k
        for (const typename V::value_type& elem : v) {
674
45.0k
            formatter.Ser(s, elem);
675
45.0k
        }
676
100k
    }
void VectorFormatter<TxInUndoFormatter>::Ser<HashWriter, std::vector<Coin, std::allocator<Coin>>>(HashWriter&, std::vector<Coin, std::allocator<Coin>> const&)
Line
Count
Source
670
45.0k
    {
671
45.0k
        Formatter formatter;
672
45.0k
        WriteCompactSize(s, v.size());
673
69.5k
        for (const typename V::value_type& elem : v) {
674
69.5k
            formatter.Ser(s, elem);
675
69.5k
        }
676
45.0k
    }
void VectorFormatter<DefaultFormatter>::Ser<BufferedWriter<AutoFile>, std::vector<CTxUndo, std::allocator<CTxUndo>>>(BufferedWriter<AutoFile>&, std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
670
100k
    {
671
100k
        Formatter formatter;
672
100k
        WriteCompactSize(s, v.size());
673
100k
        for (const typename V::value_type& elem : v) {
674
45.0k
            formatter.Ser(s, elem);
675
45.0k
        }
676
100k
    }
void VectorFormatter<TxInUndoFormatter>::Ser<BufferedWriter<AutoFile>, std::vector<Coin, std::allocator<Coin>>>(BufferedWriter<AutoFile>&, std::vector<Coin, std::allocator<Coin>> const&)
Line
Count
Source
670
45.0k
    {
671
45.0k
        Formatter formatter;
672
45.0k
        WriteCompactSize(s, v.size());
673
69.5k
        for (const typename V::value_type& elem : v) {
674
69.5k
            formatter.Ser(s, elem);
675
69.5k
        }
676
45.0k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
670
102k
    {
671
102k
        Formatter formatter;
672
102k
        WriteCompactSize(s, v.size());
673
153k
        for (const typename V::value_type& elem : v) {
674
153k
            formatter.Ser(s, elem);
675
153k
        }
676
102k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, std::vector<CTxIn, std::allocator<CTxIn>>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
670
270k
    {
671
270k
        Formatter formatter;
672
270k
        WriteCompactSize(s, v.size());
673
270k
        for (const typename V::value_type& elem : v) {
674
185k
            formatter.Ser(s, elem);
675
185k
        }
676
270k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, std::vector<CTxOut, std::allocator<CTxOut>>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
670
153k
    {
671
153k
        Formatter formatter;
672
153k
        WriteCompactSize(s, v.size());
673
381k
        for (const typename V::value_type& elem : v) {
674
381k
            formatter.Ser(s, elem);
675
381k
        }
676
153k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
670
141k
    {
671
141k
        Formatter formatter;
672
141k
        WriteCompactSize(s, v.size());
673
921k
        for (const typename V::value_type& elem : v) {
674
921k
            formatter.Ser(s, elem);
675
921k
        }
676
141k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<AutoFile&, TransactionSerParams>, std::vector<CTxIn, std::allocator<CTxIn>>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
670
2.35k
    {
671
2.35k
        Formatter formatter;
672
2.35k
        WriteCompactSize(s, v.size());
673
2.38k
        for (const typename V::value_type& elem : v) {
674
2.38k
            formatter.Ser(s, elem);
675
2.38k
        }
676
2.35k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<AutoFile&, TransactionSerParams>, std::vector<CTxOut, std::allocator<CTxOut>>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
670
1.21k
    {
671
1.21k
        Formatter formatter;
672
1.21k
        WriteCompactSize(s, v.size());
673
1.87k
        for (const typename V::value_type& elem : v) {
674
1.87k
            formatter.Ser(s, elem);
675
1.87k
        }
676
1.21k
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<AutoFile&, TransactionSerParams>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
670
2.26k
    {
671
2.26k
        Formatter formatter;
672
2.26k
        WriteCompactSize(s, v.size());
673
4.51k
        for (const typename V::value_type& elem : v) {
674
4.51k
            formatter.Ser(s, elem);
675
4.51k
        }
676
2.26k
    }
block_policy_estimator.cpp:void VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>::Ser<AutoFile, std::vector<double, std::allocator<double>>>(AutoFile&, std::vector<double, std::allocator<double>> const&)
Line
Count
Source
670
181k
    {
671
181k
        Formatter formatter;
672
181k
        WriteCompactSize(s, v.size());
673
43.0M
        for (const typename V::value_type& elem : v) {
674
43.0M
            formatter.Ser(s, elem);
675
43.0M
        }
676
181k
    }
block_policy_estimator.cpp:void VectorFormatter<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>>::Ser<AutoFile, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>>(AutoFile&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&)
Line
Count
Source
670
6.69k
    {
671
6.69k
        Formatter formatter;
672
6.69k
        WriteCompactSize(s, v.size());
673
173k
        for (const typename V::value_type& elem : v) {
674
173k
            formatter.Ser(s, elem);
675
173k
        }
676
6.69k
    }
mempool_estimator.cpp:void VectorFormatter<(anonymous namespace)::MinedBlockStatsFormatter>::Ser<AutoFile, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>>>(AutoFile&, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>> const&)
Line
Count
Source
670
1.11k
    {
671
1.11k
        Formatter formatter;
672
1.11k
        WriteCompactSize(s, v.size());
673
3.20k
        for (const typename V::value_type& elem : v) {
674
3.20k
            formatter.Ser(s, elem);
675
3.20k
        }
676
1.11k
    }
void VectorFormatter<DefaultFormatter>::Ser<DataStream, std::vector<CCoin, std::allocator<CCoin>>>(DataStream&, std::vector<CCoin, std::allocator<CCoin>> const&)
Line
Count
Source
670
3
    {
671
3
        Formatter formatter;
672
3
        WriteCompactSize(s, v.size());
673
3
        for (const typename V::value_type& elem : v) {
674
2
            formatter.Ser(s, elem);
675
2
        }
676
3
    }
void VectorFormatter<DefaultFormatter>::Ser<ParamsStream<DataStream&, TransactionSerParams>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
670
41
    {
671
41
        Formatter formatter;
672
41
        WriteCompactSize(s, v.size());
673
74
        for (const typename V::value_type& elem : v) {
674
74
            formatter.Ser(s, elem);
675
74
        }
676
41
    }
Unexecuted instantiation: void VectorFormatter<DefaultFormatter>::Ser<DataStream, std::vector<unsigned int, std::allocator<unsigned int>>>(DataStream&, std::vector<unsigned int, std::allocator<unsigned int>> const&)
677
678
    template<typename Stream, typename V>
679
    void Unser(Stream& s, V& v)
680
1.85M
    {
681
1.85M
        Formatter formatter;
682
1.85M
        v.clear();
683
1.85M
        size_t size = ReadCompactSize(s);
684
1.85M
        size_t allocated = 0;
685
3.30M
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
1.45M
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
1.45M
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
1.45M
            v.reserve(allocated);
692
27.9M
            while (v.size() < allocated) {
693
26.5M
                v.emplace_back();
694
26.5M
                formatter.Unser(s, v.back());
695
26.5M
            }
696
1.45M
        }
697
1.85M
    };
void VectorFormatter<DefaultFormatter>::Unser<SpanReader, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(SpanReader&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
680
166
    {
681
166
        Formatter formatter;
682
166
        v.clear();
683
166
        size_t size = ReadCompactSize(s);
684
166
        size_t allocated = 0;
685
314
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
148
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
148
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
148
            v.reserve(allocated);
692
440
            while (v.size() < allocated) {
693
292
                v.emplace_back();
694
292
                formatter.Unser(s, v.back());
695
292
            }
696
148
        }
697
166
    };
void VectorFormatter<CustomUintFormatter<6, false>>::Unser<DataStream, std::vector<unsigned long, std::allocator<unsigned long>>>(DataStream&, std::vector<unsigned long, std::allocator<unsigned long>>&)
Line
Count
Source
680
21.6k
    {
681
21.6k
        Formatter formatter;
682
21.6k
        v.clear();
683
21.6k
        size_t size = ReadCompactSize(s);
684
21.6k
        size_t allocated = 0;
685
22.7k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
1.15k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
1.15k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
1.15k
            v.reserve(allocated);
692
18.7k
            while (v.size() < allocated) {
693
17.5k
                v.emplace_back();
694
17.5k
                formatter.Unser(s, v.back());
695
17.5k
            }
696
1.15k
        }
697
21.6k
    };
void VectorFormatter<DefaultFormatter>::Unser<DataStream, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>>(DataStream&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&)
Line
Count
Source
680
21.6k
    {
681
21.6k
        Formatter formatter;
682
21.6k
        v.clear();
683
21.6k
        size_t size = ReadCompactSize(s);
684
21.6k
        size_t allocated = 0;
685
43.2k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
21.6k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
21.6k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
21.6k
            v.reserve(allocated);
692
43.2k
            while (v.size() < allocated) {
693
21.6k
                v.emplace_back();
694
21.6k
                formatter.Unser(s, v.back());
695
21.6k
            }
696
21.6k
        }
697
21.6k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<DataStream&, TransactionSerParams>, std::vector<CTxIn, std::allocator<CTxIn>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
680
194k
    {
681
194k
        Formatter formatter;
682
194k
        v.clear();
683
194k
        size_t size = ReadCompactSize(s);
684
194k
        size_t allocated = 0;
685
309k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
115k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
115k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
115k
            v.reserve(allocated);
692
252k
            while (v.size() < allocated) {
693
137k
                v.emplace_back();
694
137k
                formatter.Unser(s, v.back());
695
137k
            }
696
115k
        }
697
194k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<DataStream&, TransactionSerParams>, std::vector<CTxOut, std::allocator<CTxOut>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
680
115k
    {
681
115k
        Formatter formatter;
682
115k
        v.clear();
683
115k
        size_t size = ReadCompactSize(s);
684
115k
        size_t allocated = 0;
685
230k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
115k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
115k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
115k
            v.reserve(allocated);
692
404k
            while (v.size() < allocated) {
693
289k
                v.emplace_back();
694
289k
                formatter.Unser(s, v.back());
695
289k
            }
696
115k
        }
697
115k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<DataStream&, TransactionSerParams>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
680
94.2k
    {
681
94.2k
        Formatter formatter;
682
94.2k
        v.clear();
683
94.2k
        size_t size = ReadCompactSize(s);
684
94.2k
        size_t allocated = 0;
685
187k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
93.4k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
93.4k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
93.4k
            v.reserve(allocated);
692
278k
            while (v.size() < allocated) {
693
184k
                v.emplace_back();
694
184k
                formatter.Unser(s, v.back());
695
184k
            }
696
93.4k
        }
697
94.2k
    };
void VectorFormatter<DifferenceFormatter>::Unser<DataStream, std::vector<unsigned short, std::allocator<unsigned short>>>(DataStream&, std::vector<unsigned short, std::allocator<unsigned short>>&)
Line
Count
Source
680
597
    {
681
597
        Formatter formatter;
682
597
        v.clear();
683
597
        size_t size = ReadCompactSize(s);
684
597
        size_t allocated = 0;
685
1.19k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
596
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
596
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
596
            v.reserve(allocated);
692
2.02k
            while (v.size() < allocated) {
693
1.43k
                v.emplace_back();
694
1.43k
                formatter.Unser(s, v.back());
695
1.43k
            }
696
596
        }
697
597
    };
void VectorFormatter<DefaultFormatter>::Unser<DataStream, std::vector<CTxIn, std::allocator<CTxIn>>>(DataStream&, std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
680
264
    {
681
264
        Formatter formatter;
682
264
        v.clear();
683
264
        size_t size = ReadCompactSize(s);
684
264
        size_t allocated = 0;
685
484
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
220
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
220
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
220
            v.reserve(allocated);
692
5.01k
            while (v.size() < allocated) {
693
4.79k
                v.emplace_back();
694
4.79k
                formatter.Unser(s, v.back());
695
4.79k
            }
696
220
        }
697
264
    };
void VectorFormatter<DefaultFormatter>::Unser<DataStream, std::vector<CTxOut, std::allocator<CTxOut>>>(DataStream&, std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
680
220
    {
681
220
        Formatter formatter;
682
220
        v.clear();
683
220
        size_t size = ReadCompactSize(s);
684
220
        size_t allocated = 0;
685
439
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
219
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
219
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
219
            v.reserve(allocated);
692
5.00k
            while (v.size() < allocated) {
693
4.78k
                v.emplace_back();
694
4.78k
                formatter.Unser(s, v.back());
695
4.78k
            }
696
219
        }
697
220
    };
void VectorFormatter<DefaultFormatter>::Unser<DataStream, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(DataStream&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
680
4.59k
    {
681
4.59k
        Formatter formatter;
682
4.59k
        v.clear();
683
4.59k
        size_t size = ReadCompactSize(s);
684
4.59k
        size_t allocated = 0;
685
9.14k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
4.55k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
4.55k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
4.55k
            v.reserve(allocated);
692
13.6k
            while (v.size() < allocated) {
693
9.12k
                v.emplace_back();
694
9.12k
                formatter.Unser(s, v.back());
695
9.12k
            }
696
4.55k
        }
697
4.59k
    };
void VectorFormatter<DefaultFormatter>::Unser<SpanReader, std::vector<CTxIn, std::allocator<CTxIn>>>(SpanReader&, std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
680
1
    {
681
1
        Formatter formatter;
682
1
        v.clear();
683
1
        size_t size = ReadCompactSize(s);
684
1
        size_t allocated = 0;
685
2
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
1
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
1
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
1
            v.reserve(allocated);
692
2
            while (v.size() < allocated) {
693
1
                v.emplace_back();
694
1
                formatter.Unser(s, v.back());
695
1
            }
696
1
        }
697
1
    };
void VectorFormatter<DefaultFormatter>::Unser<SpanReader, std::vector<CTxOut, std::allocator<CTxOut>>>(SpanReader&, std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
680
1
    {
681
1
        Formatter formatter;
682
1
        v.clear();
683
1
        size_t size = ReadCompactSize(s);
684
1
        size_t allocated = 0;
685
2
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
1
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
1
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
1
            v.reserve(allocated);
692
3
            while (v.size() < allocated) {
693
2
                v.emplace_back();
694
2
                formatter.Unser(s, v.back());
695
2
            }
696
1
        }
697
1
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<DataStream&, TransactionSerParams>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
680
34.8k
    {
681
34.8k
        Formatter formatter;
682
34.8k
        v.clear();
683
34.8k
        size_t size = ReadCompactSize(s);
684
34.8k
        size_t allocated = 0;
685
69.6k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
34.8k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
34.8k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
34.8k
            v.reserve(allocated);
692
92.4k
            while (v.size() < allocated) {
693
57.6k
                v.emplace_back();
694
57.6k
                formatter.Unser(s, v.back());
695
57.6k
            }
696
34.8k
        }
697
34.8k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<SpanReader&, CAddress::SerParams>, std::vector<CAddress, std::allocator<CAddress>>>(ParamsStream<SpanReader&, CAddress::SerParams>&, std::vector<CAddress, std::allocator<CAddress>>&)
Line
Count
Source
680
3
    {
681
3
        Formatter formatter;
682
3
        v.clear();
683
3
        size_t size = ReadCompactSize(s);
684
3
        size_t allocated = 0;
685
6
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
3
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
3
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
3
            v.reserve(allocated);
692
10
            while (v.size() < allocated) {
693
7
                v.emplace_back();
694
7
                formatter.Unser(s, v.back());
695
7
            }
696
3
        }
697
3
    };
void VectorFormatter<DefaultFormatter>::Unser<DataStream, std::vector<uint256, std::allocator<uint256>>>(DataStream&, std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
680
16.8k
    {
681
16.8k
        Formatter formatter;
682
16.8k
        v.clear();
683
16.8k
        size_t size = ReadCompactSize(s);
684
16.8k
        size_t allocated = 0;
685
20.1k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
3.26k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
3.26k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
3.26k
            v.reserve(allocated);
692
82.1k
            while (v.size() < allocated) {
693
78.9k
                v.emplace_back();
694
78.9k
                formatter.Unser(s, v.back());
695
78.9k
            }
696
3.26k
        }
697
16.8k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<SpanReader&, TransactionSerParams>, std::vector<CTxIn, std::allocator<CTxIn>>>(ParamsStream<SpanReader&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
680
449k
    {
681
449k
        Formatter formatter;
682
449k
        v.clear();
683
449k
        size_t size = ReadCompactSize(s);
684
449k
        size_t allocated = 0;
685
689k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
239k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
239k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
239k
            v.reserve(allocated);
692
572k
            while (v.size() < allocated) {
693
332k
                v.emplace_back();
694
332k
                formatter.Unser(s, v.back());
695
332k
            }
696
239k
        }
697
449k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<SpanReader&, TransactionSerParams>, std::vector<CTxOut, std::allocator<CTxOut>>>(ParamsStream<SpanReader&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
680
240k
    {
681
240k
        Formatter formatter;
682
240k
        v.clear();
683
240k
        size_t size = ReadCompactSize(s);
684
240k
        size_t allocated = 0;
685
480k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
240k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
240k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
240k
            v.reserve(allocated);
692
761k
            while (v.size() < allocated) {
693
521k
                v.emplace_back();
694
521k
                formatter.Unser(s, v.back());
695
521k
            }
696
240k
        }
697
240k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<SpanReader&, TransactionSerParams>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(ParamsStream<SpanReader&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
680
294k
    {
681
294k
        Formatter formatter;
682
294k
        v.clear();
683
294k
        size_t size = ReadCompactSize(s);
684
294k
        size_t allocated = 0;
685
562k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
268k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
268k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
268k
            v.reserve(allocated);
692
2.14M
            while (v.size() < allocated) {
693
1.87M
                v.emplace_back();
694
1.87M
                formatter.Unser(s, v.back());
695
1.87M
            }
696
268k
        }
697
294k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<DataStream&, serialize_tests::BaseFormat>, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>&)
Line
Count
Source
680
2
    {
681
2
        Formatter formatter;
682
2
        v.clear();
683
2
        size_t size = ReadCompactSize(s);
684
2
        size_t allocated = 0;
685
4
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
2
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
2
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
2
            v.reserve(allocated);
692
6
            while (v.size() < allocated) {
693
4
                v.emplace_back();
694
4
                formatter.Unser(s, v.back());
695
4
            }
696
2
        }
697
2
    };
void VectorFormatter<DefaultFormatter>::Unser<SpanReader, std::vector<uint256, std::allocator<uint256>>>(SpanReader&, std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
680
130
    {
681
130
        Formatter formatter;
682
130
        v.clear();
683
130
        size_t size = ReadCompactSize(s);
684
130
        size_t allocated = 0;
685
260
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
130
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
130
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
130
            v.reserve(allocated);
692
1.91k
            while (v.size() < allocated) {
693
1.78k
                v.emplace_back();
694
1.78k
                formatter.Unser(s, v.back());
695
1.78k
            }
696
130
        }
697
130
    };
void VectorFormatter<DefaultFormatter>::Unser<DataStream, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>>(DataStream&, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&)
Line
Count
Source
680
11.4k
    {
681
11.4k
        Formatter formatter;
682
11.4k
        v.clear();
683
11.4k
        size_t size = ReadCompactSize(s);
684
11.4k
        size_t allocated = 0;
685
11.4k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
0
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
0
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
0
            v.reserve(allocated);
692
0
            while (v.size() < allocated) {
693
0
                v.emplace_back();
694
0
                formatter.Unser(s, v.back());
695
0
            }
696
0
        }
697
11.4k
    };
void VectorFormatter<DefaultFormatter>::Unser<DataStream, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(DataStream&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
Line
Count
Source
680
11.4k
    {
681
11.4k
        Formatter formatter;
682
11.4k
        v.clear();
683
11.4k
        size_t size = ReadCompactSize(s);
684
11.4k
        size_t allocated = 0;
685
11.4k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
0
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
0
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
0
            v.reserve(allocated);
692
0
            while (v.size() < allocated) {
693
0
                v.emplace_back();
694
0
                formatter.Unser(s, v.back());
695
0
            }
696
0
        }
697
11.4k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, std::vector<CAddress, std::allocator<CAddress>>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, std::vector<CAddress, std::allocator<CAddress>>&)
Line
Count
Source
680
31
    {
681
31
        Formatter formatter;
682
31
        v.clear();
683
31
        size_t size = ReadCompactSize(s);
684
31
        size_t allocated = 0;
685
37
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
6
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
6
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
6
            v.reserve(allocated);
692
14
            while (v.size() < allocated) {
693
8
                v.emplace_back();
694
8
                formatter.Unser(s, v.back());
695
8
            }
696
6
        }
697
31
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<AutoFile&, TransactionSerParams>, std::vector<CTxIn, std::allocator<CTxIn>>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
680
972
    {
681
972
        Formatter formatter;
682
972
        v.clear();
683
972
        size_t size = ReadCompactSize(s);
684
972
        size_t allocated = 0;
685
1.47k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
500
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
500
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
500
            v.reserve(allocated);
692
1.01k
            while (v.size() < allocated) {
693
517
                v.emplace_back();
694
517
                formatter.Unser(s, v.back());
695
517
            }
696
500
        }
697
972
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<AutoFile&, TransactionSerParams>, std::vector<CTxOut, std::allocator<CTxOut>>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
680
500
    {
681
500
        Formatter formatter;
682
500
        v.clear();
683
500
        size_t size = ReadCompactSize(s);
684
500
        size_t allocated = 0;
685
1.00k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
500
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
500
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
500
            v.reserve(allocated);
692
1.33k
            while (v.size() < allocated) {
693
832
                v.emplace_back();
694
832
                formatter.Unser(s, v.back());
695
832
            }
696
500
        }
697
500
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<AutoFile&, TransactionSerParams>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
680
489
    {
681
489
        Formatter formatter;
682
489
        v.clear();
683
489
        size_t size = ReadCompactSize(s);
684
489
        size_t allocated = 0;
685
978
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
489
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
489
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
489
            v.reserve(allocated);
692
1.34k
            while (v.size() < allocated) {
693
860
                v.emplace_back();
694
860
                formatter.Unser(s, v.back());
695
860
            }
696
489
        }
697
489
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<DataStream&, CAddress::SerParams>, std::vector<CAddress, std::allocator<CAddress>>>(ParamsStream<DataStream&, CAddress::SerParams>&, std::vector<CAddress, std::allocator<CAddress>>&)
Line
Count
Source
680
58
    {
681
58
        Formatter formatter;
682
58
        v.clear();
683
58
        size_t size = ReadCompactSize(s);
684
58
        size_t allocated = 0;
685
106
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
48
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
48
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
48
            v.reserve(allocated);
692
6.95k
            while (v.size() < allocated) {
693
6.90k
                v.emplace_back();
694
6.90k
                formatter.Unser(s, v.back());
695
6.90k
            }
696
48
        }
697
58
    };
void VectorFormatter<DefaultFormatter>::Unser<DataStream, std::vector<CInv, std::allocator<CInv>>>(DataStream&, std::vector<CInv, std::allocator<CInv>>&)
Line
Count
Source
680
39.1k
    {
681
39.1k
        Formatter formatter;
682
39.1k
        v.clear();
683
39.1k
        size_t size = ReadCompactSize(s);
684
39.1k
        size_t allocated = 0;
685
78.3k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
39.1k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
39.1k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
39.1k
            v.reserve(allocated);
692
206k
            while (v.size() < allocated) {
693
167k
                v.emplace_back();
694
167k
                formatter.Unser(s, v.back());
695
167k
            }
696
39.1k
        }
697
39.1k
    };
void VectorFormatter<DefaultFormatter>::Unser<HashVerifier<BufferedReader<AutoFile>>, std::vector<CTxUndo, std::allocator<CTxUndo>>>(HashVerifier<BufferedReader<AutoFile>>&, std::vector<CTxUndo, std::allocator<CTxUndo>>&)
Line
Count
Source
680
33.7k
    {
681
33.7k
        Formatter formatter;
682
33.7k
        v.clear();
683
33.7k
        size_t size = ReadCompactSize(s);
684
33.7k
        size_t allocated = 0;
685
37.0k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
3.33k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
3.33k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
3.33k
            v.reserve(allocated);
692
24.3k
            while (v.size() < allocated) {
693
21.0k
                v.emplace_back();
694
21.0k
                formatter.Unser(s, v.back());
695
21.0k
            }
696
3.33k
        }
697
33.7k
    };
void VectorFormatter<TxInUndoFormatter>::Unser<HashVerifier<BufferedReader<AutoFile>>, std::vector<Coin, std::allocator<Coin>>>(HashVerifier<BufferedReader<AutoFile>>&, std::vector<Coin, std::allocator<Coin>>&)
Line
Count
Source
680
21.0k
    {
681
21.0k
        Formatter formatter;
682
21.0k
        v.clear();
683
21.0k
        size_t size = ReadCompactSize(s);
684
21.0k
        size_t allocated = 0;
685
42.0k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
21.0k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
21.0k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
21.0k
            v.reserve(allocated);
692
52.1k
            while (v.size() < allocated) {
693
31.1k
                v.emplace_back();
694
31.1k
                formatter.Unser(s, v.back());
695
31.1k
            }
696
21.0k
        }
697
21.0k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<SpanReader&, TransactionSerParams>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<SpanReader&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
680
140k
    {
681
140k
        Formatter formatter;
682
140k
        v.clear();
683
140k
        size_t size = ReadCompactSize(s);
684
140k
        size_t allocated = 0;
685
280k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
139k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
139k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
139k
            v.reserve(allocated);
692
332k
            while (v.size() < allocated) {
693
192k
                v.emplace_back();
694
192k
                formatter.Unser(s, v.back());
695
192k
            }
696
139k
        }
697
140k
    };
block_policy_estimator.cpp:void VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>::Unser<AutoFile, std::vector<double, std::allocator<double>>>(AutoFile&, std::vector<double, std::allocator<double>>&)
Line
Count
Source
680
94.8k
    {
681
94.8k
        Formatter formatter;
682
94.8k
        v.clear();
683
94.8k
        size_t size = ReadCompactSize(s);
684
94.8k
        size_t allocated = 0;
685
189k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
94.8k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
94.8k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
94.8k
            v.reserve(allocated);
692
22.5M
            while (v.size() < allocated) {
693
22.4M
                v.emplace_back();
694
22.4M
                formatter.Unser(s, v.back());
695
22.4M
            }
696
94.8k
        }
697
94.8k
    };
block_policy_estimator.cpp:void VectorFormatter<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>>::Unser<AutoFile, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>>(AutoFile&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&)
Line
Count
Source
680
3.49k
    {
681
3.49k
        Formatter formatter;
682
3.49k
        v.clear();
683
3.49k
        size_t size = ReadCompactSize(s);
684
3.49k
        size_t allocated = 0;
685
6.98k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
3.49k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
3.49k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
3.49k
            v.reserve(allocated);
692
94.2k
            while (v.size() < allocated) {
693
90.7k
                v.emplace_back();
694
90.7k
                formatter.Unser(s, v.back());
695
90.7k
            }
696
3.49k
        }
697
3.49k
    };
mempool_estimator.cpp:void VectorFormatter<(anonymous namespace)::MinedBlockStatsFormatter>::Unser<AutoFile, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>>>(AutoFile&, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>>&)
Line
Count
Source
680
587
    {
681
587
        Formatter formatter;
682
587
        v.clear();
683
587
        size_t size = ReadCompactSize(s);
684
587
        size_t allocated = 0;
685
972
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
385
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
385
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
385
            v.reserve(allocated);
692
1.75k
            while (v.size() < allocated) {
693
1.36k
                v.emplace_back();
694
1.36k
                formatter.Unser(s, v.back());
695
1.36k
            }
696
385
        }
697
587
    };
void VectorFormatter<DefaultFormatter>::Unser<DataStream, std::vector<COutPoint, std::allocator<COutPoint>>>(DataStream&, std::vector<COutPoint, std::allocator<COutPoint>>&)
Line
Count
Source
680
2
    {
681
2
        Formatter formatter;
682
2
        v.clear();
683
2
        size_t size = ReadCompactSize(s);
684
2
        size_t allocated = 0;
685
4
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
2
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
2
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
2
            v.reserve(allocated);
692
4
            while (v.size() < allocated) {
693
2
                v.emplace_back();
694
2
                formatter.Unser(s, v.back());
695
2
            }
696
2
        }
697
2
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<BufferedFile&, TransactionSerParams>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<BufferedFile&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
680
1.91k
    {
681
1.91k
        Formatter formatter;
682
1.91k
        v.clear();
683
1.91k
        size_t size = ReadCompactSize(s);
684
1.91k
        size_t allocated = 0;
685
3.83k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
1.91k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
1.91k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
1.91k
            v.reserve(allocated);
692
3.92k
            while (v.size() < allocated) {
693
2.01k
                v.emplace_back();
694
2.01k
                formatter.Unser(s, v.back());
695
2.01k
            }
696
1.91k
        }
697
1.91k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<BufferedFile&, TransactionSerParams>, std::vector<CTxIn, std::allocator<CTxIn>>>(ParamsStream<BufferedFile&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
680
3.98k
    {
681
3.98k
        Formatter formatter;
682
3.98k
        v.clear();
683
3.98k
        size_t size = ReadCompactSize(s);
684
3.98k
        size_t allocated = 0;
685
5.99k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
2.01k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
2.01k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
2.01k
            v.reserve(allocated);
692
4.02k
            while (v.size() < allocated) {
693
2.01k
                v.emplace_back();
694
2.01k
                formatter.Unser(s, v.back());
695
2.01k
            }
696
2.01k
        }
697
3.98k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<BufferedFile&, TransactionSerParams>, std::vector<CTxOut, std::allocator<CTxOut>>>(ParamsStream<BufferedFile&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
680
2.01k
    {
681
2.01k
        Formatter formatter;
682
2.01k
        v.clear();
683
2.01k
        size_t size = ReadCompactSize(s);
684
2.01k
        size_t allocated = 0;
685
4.02k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
2.01k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
2.01k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
2.01k
            v.reserve(allocated);
692
5.97k
            while (v.size() < allocated) {
693
3.96k
                v.emplace_back();
694
3.96k
                formatter.Unser(s, v.back());
695
3.96k
            }
696
2.01k
        }
697
2.01k
    };
void VectorFormatter<DefaultFormatter>::Unser<ParamsStream<BufferedFile&, TransactionSerParams>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(ParamsStream<BufferedFile&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
680
1.97k
    {
681
1.97k
        Formatter formatter;
682
1.97k
        v.clear();
683
1.97k
        size_t size = ReadCompactSize(s);
684
1.97k
        size_t allocated = 0;
685
3.95k
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
1.97k
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
1.97k
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
1.97k
            v.reserve(allocated);
692
4.02k
            while (v.size() < allocated) {
693
2.05k
                v.emplace_back();
694
2.05k
                formatter.Unser(s, v.back());
695
2.05k
            }
696
1.97k
        }
697
1.97k
    };
void VectorFormatter<DefaultFormatter>::Unser<DataStream, std::vector<unsigned int, std::allocator<unsigned int>>>(DataStream&, std::vector<unsigned int, std::allocator<unsigned int>>&)
Line
Count
Source
680
277
    {
681
277
        Formatter formatter;
682
277
        v.clear();
683
277
        size_t size = ReadCompactSize(s);
684
277
        size_t allocated = 0;
685
457
        while (allocated < size) {
686
            // For DoS prevention, do not blindly allocate as much as the stream claims to contain.
687
            // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide
688
            // X MiB of data to make us allocate X+5 Mib.
689
180
            static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large");
690
180
            allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type));
691
180
            v.reserve(allocated);
692
729
            while (v.size() < allocated) {
693
549
                v.emplace_back();
694
549
                formatter.Unser(s, v.back());
695
549
            }
696
180
        }
697
277
    };
698
};
699
700
/**
701
 * Forward declarations
702
 */
703
704
/**
705
 *  string
706
 */
707
template<typename Stream, typename C> void Serialize(Stream& os, const std::basic_string<C>& str);
708
template<typename Stream, typename C> void Unserialize(Stream& is, std::basic_string<C>& str);
709
710
/**
711
 *  string_view
712
 */
713
template<typename Stream, typename C> void Serialize(Stream& os, const std::basic_string_view<C>& str);
714
template<typename Stream, typename C> void Unserialize(Stream& is, std::basic_string_view<C>& str) = delete;
715
716
/**
717
 * prevector
718
 */
719
template<typename Stream, unsigned int N, typename T> inline void Serialize(Stream& os, const prevector<N, T>& v);
720
template<typename Stream, unsigned int N, typename T> inline void Unserialize(Stream& is, prevector<N, T>& v);
721
722
/**
723
 * vector
724
 */
725
template<typename Stream, typename T, typename A> inline void Serialize(Stream& os, const std::vector<T, A>& v);
726
template<typename Stream, typename T, typename A> inline void Unserialize(Stream& is, std::vector<T, A>& v);
727
728
/**
729
 * pair
730
 */
731
template<typename Stream, typename K, typename T> void Serialize(Stream& os, const std::pair<K, T>& item);
732
template<typename Stream, typename K, typename T> void Unserialize(Stream& is, std::pair<K, T>& item);
733
734
/**
735
 * map
736
 */
737
template<typename Stream, typename K, typename T, typename Pred, typename A> void Serialize(Stream& os, const std::map<K, T, Pred, A>& m);
738
template<typename Stream, typename K, typename T, typename Pred, typename A> void Unserialize(Stream& is, std::map<K, T, Pred, A>& m);
739
740
/**
741
 * set
742
 */
743
template<typename Stream, typename K, typename Pred, typename A> void Serialize(Stream& os, const std::set<K, Pred, A>& m);
744
template<typename Stream, typename K, typename Pred, typename A> void Unserialize(Stream& is, std::set<K, Pred, A>& m);
745
746
/**
747
 * shared_ptr
748
 */
749
template<typename Stream, typename T> void Serialize(Stream& os, const std::shared_ptr<const T>& p);
750
template<typename Stream, typename T> void Unserialize(Stream& os, std::shared_ptr<const T>& p);
751
752
/**
753
 * unique_ptr
754
 */
755
template<typename Stream, typename T> void Serialize(Stream& os, const std::unique_ptr<const T>& p);
756
template<typename Stream, typename T> void Unserialize(Stream& os, std::unique_ptr<const T>& p);
757
758
759
/**
760
 * If none of the specialized versions above matched, default to calling member function.
761
 */
762
template <class T, class Stream>
763
concept Serializable = requires(T a, Stream s) { a.Serialize(s); };
764
template <typename Stream, typename T>
765
    requires Serializable<T, Stream>
766
void Serialize(Stream& os, const T& a)
767
242M
{
768
242M
    a.Serialize(os);
769
242M
}
void Serialize<SizeComputer, ParamsWrapper<TransactionSerParams, CTransaction const>>(T&, T0 const&)
Line
Count
Source
767
2.57M
{
768
2.57M
    a.Serialize(os);
769
2.57M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, CTransaction>(T&, T0 const&)
Line
Count
Source
767
3.71M
{
768
3.71M
    a.Serialize(os);
769
3.71M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>>(T&, T0 const&)
Line
Count
Source
767
4.44M
{
768
4.44M
    a.Serialize(os);
769
4.44M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, CTxIn>(T&, T0 const&)
Line
Count
Source
767
4.47M
{
768
4.47M
    a.Serialize(os);
769
4.47M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, CScript>(T&, T0 const&)
Line
Count
Source
767
11.6M
{
768
11.6M
    a.Serialize(os);
769
11.6M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, COutPoint>(T&, T0 const&)
Line
Count
Source
767
4.47M
{
768
4.47M
    a.Serialize(os);
769
4.47M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, transaction_identifier<false>>(T&, T0 const&)
Line
Count
Source
767
4.47M
{
768
4.47M
    a.Serialize(os);
769
4.47M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>>(T&, T0 const&)
Line
Count
Source
767
3.71M
{
768
3.71M
    a.Serialize(os);
769
3.71M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, CTxOut>(T&, T0 const&)
Line
Count
Source
767
7.16M
{
768
7.16M
    a.Serialize(os);
769
7.16M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>>(T&, T0 const&)
Line
Count
Source
767
954k
{
768
954k
    a.Serialize(os);
769
954k
}
void Serialize<SizeComputer, ParamsWrapper<TransactionSerParams, CBlock const>>(T&, T0 const&)
Line
Count
Source
767
710k
{
768
710k
    a.Serialize(os);
769
710k
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, CBlock>(T&, T0 const&)
Line
Count
Source
767
710k
{
768
710k
    a.Serialize(os);
769
710k
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>>(T&, T0 const&)
Line
Count
Source
767
710k
{
768
710k
    a.Serialize(os);
769
710k
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, CBlockHeader>(T&, T0 const&)
Line
Count
Source
767
710k
{
768
710k
    a.Serialize(os);
769
710k
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, uint256>(T&, T0 const&)
Line
Count
Source
767
1.42M
{
768
1.42M
    a.Serialize(os);
769
1.42M
}
void Serialize<SizeComputer, ParamsWrapper<TransactionSerParams, CTxIn const>>(T&, T0 const&)
Line
Count
Source
767
4.99k
{
768
4.99k
    a.Serialize(os);
769
4.99k
}
void Serialize<SizeComputer, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>>(T&, T0 const&)
Line
Count
Source
767
116k
{
768
116k
    a.Serialize(os);
769
116k
}
void Serialize<DataStream, uint256>(T&, T0 const&)
Line
Count
Source
767
1.08M
{
768
1.08M
    a.Serialize(os);
769
1.08M
}
void Serialize<DataStream, ParamsWrapper<CAddress::SerParams, AddrInfo>>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, AddrInfo>(T&, T0 const&)
Line
Count
Source
767
17
{
768
17
    a.Serialize(os);
769
17
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, CAddress>(T&, T0 const&)
Line
Count
Source
767
23
{
768
23
    a.Serialize(os);
769
23
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>>(T&, T0 const&)
Line
Count
Source
767
23
{
768
23
    a.Serialize(os);
769
23
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(T&, T0 const&)
Line
Count
Source
767
18
{
768
18
    a.Serialize(os);
769
18
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>>(T&, T0 const&)
Line
Count
Source
767
5
{
768
5
    a.Serialize(os);
769
5
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService const>>(T&, T0 const&)
Line
Count
Source
767
23
{
768
23
    a.Serialize(os);
769
23
}
void Serialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, CService>(T&, T0 const&)
Line
Count
Source
767
23
{
768
23
    a.Serialize(os);
769
23
}
void Serialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr>(T&, T0 const&)
Line
Count
Source
767
23
{
768
23
    a.Serialize(os);
769
23
}
Unexecuted instantiation: void Serialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(T&, T0 const&)
void Serialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(T&, T0 const&)
Line
Count
Source
767
23
{
768
23
    a.Serialize(os);
769
23
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, CNetAddr>(T&, T0 const&)
Line
Count
Source
767
27
{
768
27
    a.Serialize(os);
769
27
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>>(T&, T0 const&)
Line
Count
Source
767
17
{
768
17
    a.Serialize(os);
769
17
}
void Serialize<DataStream, AddrMan>(T&, T0 const&)
Line
Count
Source
767
7
{
768
7
    a.Serialize(os);
769
7
}
void Serialize<DataStream, CExtKey>(T&, T0 const&)
Line
Count
Source
767
18
{
768
18
    a.Serialize(os);
769
18
}
void Serialize<DataStream, Wrapper<CustomUintFormatter<4, true>, unsigned int const&>>(T&, T0 const&)
Line
Count
Source
767
40
{
768
40
    a.Serialize(os);
769
40
}
void Serialize<DataStream, ChainCode>(T&, T0 const&)
Line
Count
Source
767
40
{
768
40
    a.Serialize(os);
769
40
}
void Serialize<DataStream, CExtPubKey>(T&, T0 const&)
Line
Count
Source
767
22
{
768
22
    a.Serialize(os);
769
22
}
void Serialize<DataStream, CBlockHeaderAndShortTxIDs>(T&, T0 const&)
Line
Count
Source
767
4
{
768
4
    a.Serialize(os);
769
4
}
void Serialize<DataStream, CBlockHeader>(T&, T0 const&)
Line
Count
Source
767
97.0k
{
768
97.0k
    a.Serialize(os);
769
97.0k
}
void Serialize<DataStream, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>>(T&, T0 const&)
Line
Count
Source
767
9
{
768
9
    a.Serialize(os);
769
9
}
void Serialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&>>(T&, T0 const&)
Line
Count
Source
767
9
{
768
9
    a.Serialize(os);
769
9
}
void Serialize<DataStream, PrefilledTransaction>(T&, T0 const&)
Line
Count
Source
767
11
{
768
11
    a.Serialize(os);
769
11
}
void Serialize<DataStream, Wrapper<CompactSizeFormatter<true>, unsigned short const&>>(T&, T0 const&)
Line
Count
Source
767
11
{
768
11
    a.Serialize(os);
769
11
}
void Serialize<DataStream, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>>(T&, T0 const&)
Line
Count
Source
767
11
{
768
11
    a.Serialize(os);
769
11
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>(T&, T0 const&)
Line
Count
Source
767
11
{
768
11
    a.Serialize(os);
769
11
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, CTransaction>(T&, T0 const&)
Line
Count
Source
767
100k
{
768
100k
    a.Serialize(os);
769
100k
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>>(T&, T0 const&)
Line
Count
Source
767
196k
{
768
196k
    a.Serialize(os);
769
196k
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, CTxIn>(T&, T0 const&)
Line
Count
Source
767
125k
{
768
125k
    a.Serialize(os);
769
125k
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, COutPoint>(T&, T0 const&)
Line
Count
Source
767
125k
{
768
125k
    a.Serialize(os);
769
125k
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, transaction_identifier<false>>(T&, T0 const&)
Line
Count
Source
767
125k
{
768
125k
    a.Serialize(os);
769
125k
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, CScript>(T&, T0 const&)
Line
Count
Source
767
393k
{
768
393k
    a.Serialize(os);
769
393k
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>>(T&, T0 const&)
Line
Count
Source
767
101k
{
768
101k
    a.Serialize(os);
769
101k
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, CTxOut>(T&, T0 const&)
Line
Count
Source
767
267k
{
768
267k
    a.Serialize(os);
769
267k
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>>(T&, T0 const&)
Line
Count
Source
767
116k
{
768
116k
    a.Serialize(os);
769
116k
}
void Serialize<DataStream, blockencodings_tests::TestHeaderAndShortIDs>(T&, T0 const&)
Line
Count
Source
767
5
{
768
5
    a.Serialize(os);
769
5
}
void Serialize<DataStream, BlockTransactionsRequest>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<DataStream, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&>>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<DataStream, BlockFilter>(T&, T0 const&)
Line
Count
Source
767
3
{
768
3
    a.Serialize(os);
769
3
}
void Serialize<DataStream, CBloomFilter>(T&, T0 const&)
Line
Count
Source
767
3
{
768
3
    a.Serialize(os);
769
3
}
void Serialize<DataStream, CMerkleBlock>(T&, T0 const&)
Line
Count
Source
767
14
{
768
14
    a.Serialize(os);
769
14
}
void Serialize<DataStream, CPartialMerkleTree>(T&, T0 const&)
Line
Count
Source
767
182
{
768
182
    a.Serialize(os);
769
182
}
void Serialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>>(T&, T0 const&)
Line
Count
Source
767
29.9k
{
768
29.9k
    a.Serialize(os);
769
29.9k
}
void Serialize<VectorWriter, Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>> const&>>(T&, T0 const&)
Line
Count
Source
767
227
{
768
227
    a.Serialize(os);
769
227
}
void Serialize<VectorWriter, Wrapper<VarIntFormatter<(VarIntMode)1>, int const&>>(T&, T0 const&)
Line
Count
Source
767
25.0k
{
768
25.0k
    a.Serialize(os);
769
25.0k
}
void Serialize<VectorWriter, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>>(T&, T0 const&)
Line
Count
Source
767
124k
{
768
124k
    a.Serialize(os);
769
124k
}
void Serialize<VectorWriter, Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>> const&>>(T&, T0 const&)
Line
Count
Source
767
227
{
768
227
    a.Serialize(os);
769
227
}
void Serialize<VectorWriter, Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>> const&>>(T&, T0 const&)
Line
Count
Source
767
227
{
768
227
    a.Serialize(os);
769
227
}
void Serialize<VectorWriter, Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>> const&>>(T&, T0 const&)
Line
Count
Source
767
132
{
768
132
    a.Serialize(os);
769
132
}
void Serialize<VectorWriter, Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>> const&>>(T&, T0 const&)
Line
Count
Source
767
125
{
768
125
    a.Serialize(os);
769
125
}
void Serialize<VectorWriter, Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>>&>>(T&, T0 const&)
Line
Count
Source
767
7
{
768
7
    a.Serialize(os);
769
7
}
void Serialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>>(T&, T0 const&)
Line
Count
Source
767
289k
{
768
289k
    a.Serialize(os);
769
289k
}
void Serialize<DataStream, MuHash3072>(T&, T0 const&)
Line
Count
Source
767
120
{
768
120
    a.Serialize(os);
769
120
}
void Serialize<DataStream, Num3072>(T&, T0 const&)
Line
Count
Source
767
240
{
768
240
    a.Serialize(os);
769
240
}
void Serialize<DataStream, dbwrapper_tests::StringContentsSerializer>(T&, T0 const&)
Line
Count
Source
767
102
{
768
102
    a.Serialize(os);
769
102
}
void Serialize<VectorWriter, ParamsWrapper<TransactionSerParams, CTransaction const>>(T&, T0 const&)
Line
Count
Source
767
13.9k
{
768
13.9k
    a.Serialize(os);
769
13.9k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, CTransaction>(T&, T0 const&)
Line
Count
Source
767
59.3k
{
768
59.3k
    a.Serialize(os);
769
59.3k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>>(T&, T0 const&)
Line
Count
Source
767
92.2k
{
768
92.2k
    a.Serialize(os);
769
92.2k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, CTxIn>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, COutPoint>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, transaction_identifier<false>>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, CScript>(T&, T0 const&)
Line
Count
Source
767
240k
{
768
240k
    a.Serialize(os);
769
240k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>>(T&, T0 const&)
Line
Count
Source
767
59.3k
{
768
59.3k
    a.Serialize(os);
769
59.3k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, CTxOut>(T&, T0 const&)
Line
Count
Source
767
170k
{
768
170k
    a.Serialize(os);
769
170k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>>(T&, T0 const&)
Line
Count
Source
767
42.0k
{
768
42.0k
    a.Serialize(os);
769
42.0k
}
void Serialize<AutoFile, Wrapper<LimitedStringFormatter<256ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>>(T&, T0 const&)
Line
Count
Source
767
3
{
768
3
    a.Serialize(os);
769
3
}
void Serialize<HashWriter, ParamsWrapper<TransactionSerParams, CMutableTransaction>>(T&, T0 const&)
Line
Count
Source
767
50.0k
{
768
50.0k
    a.Serialize(os);
769
50.0k
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, CMutableTransaction>(T&, T0 const&)
Line
Count
Source
767
711k
{
768
711k
    a.Serialize(os);
769
711k
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>>(T&, T0 const&)
Line
Count
Source
767
2.81M
{
768
2.81M
    a.Serialize(os);
769
2.81M
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, CTxIn>(T&, T0 const&)
Line
Count
Source
767
2.10M
{
768
2.10M
    a.Serialize(os);
769
2.10M
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, COutPoint>(T&, T0 const&)
Line
Count
Source
767
2.10M
{
768
2.10M
    a.Serialize(os);
769
2.10M
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, transaction_identifier<false>>(T&, T0 const&)
Line
Count
Source
767
2.10M
{
768
2.10M
    a.Serialize(os);
769
2.10M
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, CScript>(T&, T0 const&)
Line
Count
Source
767
5.94M
{
768
5.94M
    a.Serialize(os);
769
5.94M
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>>(T&, T0 const&)
Line
Count
Source
767
2.41M
{
768
2.41M
    a.Serialize(os);
769
2.41M
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, CTxOut>(T&, T0 const&)
Line
Count
Source
767
3.83M
{
768
3.83M
    a.Serialize(os);
769
3.83M
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>>(T&, T0 const&)
Line
Count
Source
767
556k
{
768
556k
    a.Serialize(os);
769
556k
}
void Serialize<DataStream, CPubKey>(T&, T0 const&)
Line
Count
Source
767
5.89k
{
768
5.89k
    a.Serialize(os);
769
5.89k
}
void Serialize<SizeComputer, ParamsWrapper<TransactionSerParams, CMutableTransaction>>(T&, T0 const&)
Line
Count
Source
767
61
{
768
61
    a.Serialize(os);
769
61
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, CMutableTransaction>(T&, T0 const&)
Line
Count
Source
767
61
{
768
61
    a.Serialize(os);
769
61
}
void Serialize<DataStream, CMessageHeader>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<DataStream, ParamsWrapper<CAddress::SerParams, CNetAddr>>(T&, T0 const&)
Line
Count
Source
767
10
{
768
10
    a.Serialize(os);
769
10
}
void Serialize<VectorWriter, ParamsWrapper<CAddress::SerParams, CService const>>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, CService>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, CNetAddr>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
Unexecuted instantiation: void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(T&, T0 const&)
void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<DataStream, ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>> const>>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&>>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<int, std::allocator<int>> const&>>(T&, T0 const&)
Line
Count
Source
767
265k
{
768
265k
    a.Serialize(os);
769
265k
}
void Serialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, prevector<8u, int, unsigned int, int> const&>>(T&, T0 const&)
Line
Count
Source
767
265k
{
768
265k
    a.Serialize(os);
769
265k
}
void Serialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>>(T&, T0 const&)
Line
Count
Source
767
217k
{
768
217k
    a.Serialize(os);
769
217k
}
void Serialize<SizeComputer, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>>(T&, T0 const&)
Line
Count
Source
767
100k
{
768
100k
    a.Serialize(os);
769
100k
}
void Serialize<SizeComputer, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>>(T&, T0 const&)
Line
Count
Source
767
69.6k
{
768
69.6k
    a.Serialize(os);
769
69.6k
}
void Serialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, signed char&>>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned char&>>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, short&>>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned short&>>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(T&, T0 const&)
Line
Count
Source
767
6.11M
{
768
6.11M
    a.Serialize(os);
769
6.11M
}
void Serialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, long long&>>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long long&>>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<DataStream, serialize_tests::CSerializeMethodsTestSingle>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<DataStream, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const>>(T&, T0 const&)
Line
Count
Source
767
18.8k
{
768
18.8k
    a.Serialize(os);
769
18.8k
}
void Serialize<DataStream, serialize_tests::CSerializeMethodsTestMany>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<DataStream, ParamsWrapper<TransactionSerParams, CMutableTransaction>>(T&, T0 const&)
Line
Count
Source
767
361
{
768
361
    a.Serialize(os);
769
361
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, CMutableTransaction>(T&, T0 const&)
Line
Count
Source
767
361
{
768
361
    a.Serialize(os);
769
361
}
void Serialize<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>, serialize_tests::Base>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>, serialize_tests::OtherParamChecker>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>, ParamsWrapper<serialize_tests::OtherParam, serialize_tests::OtherParamChecker const>>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>, serialize_tests::OtherParamChecker>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::Base>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<DataStream, ParamsWrapper<serialize_tests::BaseFormat, serialize_tests::Base>>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<ParamsStream<DataStream&, serialize_tests::BaseFormat>, serialize_tests::Base>(T&, T0 const&)
Line
Count
Source
767
6
{
768
6
    a.Serialize(os);
769
6
}
void Serialize<DataStream, ParamsWrapper<serialize_tests::BaseFormat, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>>>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<ParamsStream<DataStream&, serialize_tests::BaseFormat>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>> const&>>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<DataStream, ParamsWrapper<serialize_tests::DerivedAndBaseFormat, serialize_tests::Derived>>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>, serialize_tests::Derived>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>, ParamsWrapper<serialize_tests::BaseFormat, serialize_tests::Base const>>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>, serialize_tests::Base>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<DataStream, Obfuscation>(T&, T0 const&)
Line
Count
Source
767
564
{
768
564
    a.Serialize(os);
769
564
}
void Serialize<SizeComputer, ParamsWrapper<TransactionSerParams, CTransaction>>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<DataStream, txindex::BlockTxPosition>(T&, T0 const&)
Line
Count
Source
767
4.58k
{
768
4.58k
    a.Serialize(os);
769
4.58k
}
void Serialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&>>(T&, T0 const&)
Line
Count
Source
767
456k
{
768
456k
    a.Serialize(os);
769
456k
}
void Serialize<DataStream, Wrapper<CustomUintFormatter<3, true>, unsigned int const&>>(T&, T0 const&)
Line
Count
Source
767
4.58k
{
768
4.58k
    a.Serialize(os);
769
4.58k
}
void Serialize<DataStream, txindex::BlockSeqKey>(T&, T0 const&)
Line
Count
Source
767
4.31k
{
768
4.31k
    a.Serialize(os);
769
4.31k
}
void Serialize<DataStream, txindex::DBKey>(T&, T0 const&)
Line
Count
Source
767
4.57k
{
768
4.57k
    a.Serialize(os);
769
4.57k
}
void Serialize<DataStream, Wrapper<CustomUintFormatter<5, true>, unsigned long const&>>(T&, T0 const&)
Line
Count
Source
767
4.57k
{
768
4.57k
    a.Serialize(os);
769
4.57k
}
void Serialize<SizeComputer, CBlockHeader>(T&, T0 const&)
Line
Count
Source
767
35.6k
{
768
35.6k
    a.Serialize(os);
769
35.6k
}
void Serialize<SizeComputer, uint256>(T&, T0 const&)
Line
Count
Source
767
87.2k
{
768
87.2k
    a.Serialize(os);
769
87.2k
}
void Serialize<DataStream, CDiskTxPos>(T&, T0 const&)
Line
Count
Source
767
46
{
768
46
    a.Serialize(os);
769
46
}
void Serialize<DataStream, FlatFilePos>(T&, T0 const&)
Line
Count
Source
767
8.33k
{
768
8.33k
    a.Serialize(os);
769
8.33k
}
void Serialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int const&>>(T&, T0 const&)
Line
Count
Source
767
226k
{
768
226k
    a.Serialize(os);
769
226k
}
void Serialize<DataStream, CBlockLocator>(T&, T0 const&)
Line
Count
Source
767
25.7k
{
768
25.7k
    a.Serialize(os);
769
25.7k
}
void Serialize<HashWriter, transaction_identifier<true>>(T&, T0 const&)
Line
Count
Source
767
888
{
768
888
    a.Serialize(os);
769
888
}
void Serialize<HashWriter, transaction_identifier<false>>(T&, T0 const&)
Line
Count
Source
767
21.5M
{
768
21.5M
    a.Serialize(os);
769
21.5M
}
void Serialize<SizeComputer, uint160>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<DataStream, uint160>(T&, T0 const&)
Line
Count
Source
767
3
{
768
3
    a.Serialize(os);
769
3
}
void Serialize<SizeComputer, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>>(T&, T0 const&)
Line
Count
Source
767
1
{
768
1
    a.Serialize(os);
769
1
}
void Serialize<DataStream, PartiallySignedTransaction>(T&, T0 const&)
Line
Count
Source
767
1.14k
{
768
1.14k
    a.Serialize(os);
769
1.14k
}
void Serialize<SizeComputer, CompactSizeWriter>(T&, T0 const&)
Line
Count
Source
767
22.5k
{
768
22.5k
    a.Serialize(os);
769
22.5k
}
void Serialize<DataStream, CompactSizeWriter>(T&, T0 const&)
Line
Count
Source
767
22.5k
{
768
22.5k
    a.Serialize(os);
769
22.5k
}
void Serialize<SizeComputer, CExtPubKey>(T&, T0 const&)
Line
Count
Source
767
4
{
768
4
    a.Serialize(os);
769
4
}
void Serialize<SizeComputer, Wrapper<CustomUintFormatter<4, true>, unsigned int const&>>(T&, T0 const&)
Line
Count
Source
767
4
{
768
4
    a.Serialize(os);
769
4
}
void Serialize<SizeComputer, ChainCode>(T&, T0 const&)
Line
Count
Source
767
4
{
768
4
    a.Serialize(os);
769
4
}
void Serialize<DataStream, PSBTInput>(T&, T0 const&)
Line
Count
Source
767
1.59k
{
768
1.59k
    a.Serialize(os);
769
1.59k
}
void Serialize<SizeComputer, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const>>(T&, T0 const&)
Line
Count
Source
767
594
{
768
594
    a.Serialize(os);
769
594
}
void Serialize<SizeComputer, CTxOut>(T&, T0 const&)
Line
Count
Source
767
402k
{
768
402k
    a.Serialize(os);
769
402k
}
void Serialize<SizeComputer, CScript>(T&, T0 const&)
Line
Count
Source
767
402k
{
768
402k
    a.Serialize(os);
769
402k
}
void Serialize<DataStream, CTxOut>(T&, T0 const&)
Line
Count
Source
767
7.43k
{
768
7.43k
    a.Serialize(os);
769
7.43k
}
void Serialize<DataStream, CScript>(T&, T0 const&)
Line
Count
Source
767
10.0k
{
768
10.0k
    a.Serialize(os);
769
10.0k
}
void Serialize<SizeComputer, XOnlyPubKey>(T&, T0 const&)
Line
Count
Source
767
5.96k
{
768
5.96k
    a.Serialize(os);
769
5.96k
}
void Serialize<DataStream, XOnlyPubKey>(T&, T0 const&)
Line
Count
Source
767
5.96k
{
768
5.96k
    a.Serialize(os);
769
5.96k
}
void Serialize<VectorWriter, uint256>(T&, T0 const&)
Line
Count
Source
767
174k
{
768
174k
    a.Serialize(os);
769
174k
}
void Serialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>>(T&, T0 const&)
Line
Count
Source
767
270
{
768
270
    a.Serialize(os);
769
270
}
void Serialize<SizeComputer, transaction_identifier<false>>(T&, T0 const&)
Line
Count
Source
767
1.50k
{
768
1.50k
    a.Serialize(os);
769
1.50k
}
void Serialize<DataStream, transaction_identifier<false>>(T&, T0 const&)
Line
Count
Source
767
5.68M
{
768
5.68M
    a.Serialize(os);
769
5.68M
}
void Serialize<DataStream, PSBTOutput>(T&, T0 const&)
Line
Count
Source
767
2.41k
{
768
2.41k
    a.Serialize(os);
769
2.41k
}
void Serialize<DataStream, wallet::CWalletTx>(T&, T0 const&)
Line
Count
Source
767
24.7k
{
768
24.7k
    a.Serialize(os);
769
24.7k
}
void Serialize<DataStream, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>>(T&, T0 const&)
Line
Count
Source
767
24.7k
{
768
24.7k
    a.Serialize(os);
769
24.7k
}
void Serialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&>>(T&, T0 const&)
Line
Count
Source
767
24.7k
{
768
24.7k
    a.Serialize(os);
769
24.7k
}
void Serialize<VectorWriter, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>>(T&, T0 const&)
Line
Count
Source
767
5
{
768
5
    a.Serialize(os);
769
5
}
void Serialize<VectorWriter, ParamsWrapper<CNetAddr::SerParams, CService>>(T&, T0 const&)
Line
Count
Source
767
3.48k
{
768
3.48k
    a.Serialize(os);
769
3.48k
}
void Serialize<ParamsStream<VectorWriter&, CNetAddr::SerParams>, CService>(T&, T0 const&)
Line
Count
Source
767
3.48k
{
768
3.48k
    a.Serialize(os);
769
3.48k
}
void Serialize<ParamsStream<VectorWriter&, CNetAddr::SerParams>, CNetAddr>(T&, T0 const&)
Line
Count
Source
767
3.48k
{
768
3.48k
    a.Serialize(os);
769
3.48k
}
Unexecuted instantiation: void Serialize<ParamsStream<VectorWriter&, CNetAddr::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(T&, T0 const&)
void Serialize<ParamsStream<VectorWriter&, CNetAddr::SerParams>, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(T&, T0 const&)
Line
Count
Source
767
3.48k
{
768
3.48k
    a.Serialize(os);
769
3.48k
}
void Serialize<HashedSourceWriter<AutoFile>, AddrMan>(T&, T0 const&)
Line
Count
Source
767
1.62k
{
768
1.62k
    a.Serialize(os);
769
1.62k
}
void Serialize<AutoFile, uint256>(T&, T0 const&)
Line
Count
Source
767
10.8k
{
768
10.8k
    a.Serialize(os);
769
10.8k
}
void Serialize<HashedSourceWriter<AutoFile>, ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>> const>>(T&, T0 const&)
Line
Count
Source
767
39
{
768
39
    a.Serialize(os);
769
39
}
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&>>(T&, T0 const&)
Line
Count
Source
767
39
{
768
39
    a.Serialize(os);
769
39
}
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, CAddress>(T&, T0 const&)
Line
Count
Source
767
50.3k
{
768
50.3k
    a.Serialize(os);
769
50.3k
}
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>>(T&, T0 const&)
Line
Count
Source
767
50.3k
{
768
50.3k
    a.Serialize(os);
769
50.3k
}
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(T&, T0 const&)
Line
Count
Source
767
50.3k
{
768
50.3k
    a.Serialize(os);
769
50.3k
}
Unexecuted instantiation: void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>>(T&, T0 const&)
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService const>>(T&, T0 const&)
Line
Count
Source
767
50.3k
{
768
50.3k
    a.Serialize(os);
769
50.3k
}
void Serialize<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, CService>(T&, T0 const&)
Line
Count
Source
767
50.3k
{
768
50.3k
    a.Serialize(os);
769
50.3k
}
void Serialize<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr>(T&, T0 const&)
Line
Count
Source
767
50.3k
{
768
50.3k
    a.Serialize(os);
769
50.3k
}
Unexecuted instantiation: void Serialize<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(T&, T0 const&)
void Serialize<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(T&, T0 const&)
Line
Count
Source
767
50.3k
{
768
50.3k
    a.Serialize(os);
769
50.3k
}
void Serialize<HashWriter, uint256>(T&, T0 const&)
Line
Count
Source
767
38.7M
{
768
38.7M
    a.Serialize(os);
769
38.7M
}
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, uint256>(T&, T0 const&)
Line
Count
Source
767
3.25k
{
768
3.25k
    a.Serialize(os);
769
3.25k
}
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, AddrInfo>(T&, T0 const&)
Line
Count
Source
767
50.3k
{
768
50.3k
    a.Serialize(os);
769
50.3k
}
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, CNetAddr>(T&, T0 const&)
Line
Count
Source
767
50.3k
{
768
50.3k
    a.Serialize(os);
769
50.3k
}
Unexecuted instantiation: void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(T&, T0 const&)
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>>(T&, T0 const&)
Line
Count
Source
767
50.3k
{
768
50.3k
    a.Serialize(os);
769
50.3k
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, uint256>(T&, T0 const&)
Line
Count
Source
767
14
{
768
14
    a.Serialize(os);
769
14
}
void Serialize<SizeComputer, CBlockHeaderAndShortTxIDs>(T&, T0 const&)
Line
Count
Source
767
35.6k
{
768
35.6k
    a.Serialize(os);
769
35.6k
}
void Serialize<SizeComputer, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>>(T&, T0 const&)
Line
Count
Source
767
35.6k
{
768
35.6k
    a.Serialize(os);
769
35.6k
}
void Serialize<SizeComputer, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&>>(T&, T0 const&)
Line
Count
Source
767
35.6k
{
768
35.6k
    a.Serialize(os);
769
35.6k
}
void Serialize<SizeComputer, PrefilledTransaction>(T&, T0 const&)
Line
Count
Source
767
35.7k
{
768
35.7k
    a.Serialize(os);
769
35.7k
}
void Serialize<SizeComputer, Wrapper<CompactSizeFormatter<true>, unsigned short const&>>(T&, T0 const&)
Line
Count
Source
767
35.7k
{
768
35.7k
    a.Serialize(os);
769
35.7k
}
void Serialize<SizeComputer, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>>(T&, T0 const&)
Line
Count
Source
767
35.7k
{
768
35.7k
    a.Serialize(os);
769
35.7k
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>(T&, T0 const&)
Line
Count
Source
767
35.7k
{
768
35.7k
    a.Serialize(os);
769
35.7k
}
void Serialize<DataStream, index_util::DBHeightKey>(T&, T0 const&)
Line
Count
Source
767
14.3k
{
768
14.3k
    a.Serialize(os);
769
14.3k
}
void Serialize<DataStream, index_util::DBHashKey>(T&, T0 const&)
Line
Count
Source
767
268
{
768
268
    a.Serialize(os);
769
268
}
blockfilterindex.cpp:void Serialize<DataStream, (anonymous namespace)::DBVal>(T&, T0 const&)
Line
Count
Source
767
8.11k
{
768
8.11k
    a.Serialize(os);
769
8.11k
}
coinstatsindex.cpp:void Serialize<DataStream, (anonymous namespace)::DBVal>(T&, T0 const&)
Line
Count
Source
767
4.22k
{
768
4.22k
    a.Serialize(os);
769
4.22k
}
void Serialize<DataStream, txindex::BlockHashKey>(T&, T0 const&)
Line
Count
Source
767
8.81k
{
768
8.81k
    a.Serialize(os);
769
8.81k
}
void Serialize<DataStream, DBKey>(T&, T0 const&)
Line
Count
Source
767
44
{
768
44
    a.Serialize(os);
769
44
}
void Serialize<HashWriter, COutPoint>(T&, T0 const&)
Line
Count
Source
767
21.5M
{
768
21.5M
    a.Serialize(os);
769
21.5M
}
void Serialize<HashWriter, CTxOut>(T&, T0 const&)
Line
Count
Source
767
14.4M
{
768
14.4M
    a.Serialize(os);
769
14.4M
}
void Serialize<HashWriter, CScript>(T&, T0 const&)
Line
Count
Source
767
15.4M
{
768
15.4M
    a.Serialize(os);
769
15.4M
}
void Serialize<DataStream, COutPoint>(T&, T0 const&)
Line
Count
Source
767
6.20k
{
768
6.20k
    a.Serialize(os);
769
6.20k
}
void Serialize<VectorWriter, CMessageHeader>(T&, T0 const&)
Line
Count
Source
767
136k
{
768
136k
    a.Serialize(os);
769
136k
}
void Serialize<VectorWriter, CBlockHeaderAndShortTxIDs>(T&, T0 const&)
Line
Count
Source
767
18.8k
{
768
18.8k
    a.Serialize(os);
769
18.8k
}
void Serialize<VectorWriter, CBlockHeader>(T&, T0 const&)
Line
Count
Source
767
18.8k
{
768
18.8k
    a.Serialize(os);
769
18.8k
}
void Serialize<VectorWriter, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>>(T&, T0 const&)
Line
Count
Source
767
18.8k
{
768
18.8k
    a.Serialize(os);
769
18.8k
}
void Serialize<VectorWriter, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&>>(T&, T0 const&)
Line
Count
Source
767
18.8k
{
768
18.8k
    a.Serialize(os);
769
18.8k
}
void Serialize<VectorWriter, PrefilledTransaction>(T&, T0 const&)
Line
Count
Source
767
18.8k
{
768
18.8k
    a.Serialize(os);
769
18.8k
}
void Serialize<VectorWriter, Wrapper<CompactSizeFormatter<true>, unsigned short const&>>(T&, T0 const&)
Line
Count
Source
767
18.8k
{
768
18.8k
    a.Serialize(os);
769
18.8k
}
void Serialize<VectorWriter, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>>(T&, T0 const&)
Line
Count
Source
767
18.8k
{
768
18.8k
    a.Serialize(os);
769
18.8k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>(T&, T0 const&)
Line
Count
Source
767
18.8k
{
768
18.8k
    a.Serialize(os);
769
18.8k
}
void Serialize<VectorWriter, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CInv, std::allocator<CInv>> const&>>(T&, T0 const&)
Line
Count
Source
767
58.7k
{
768
58.7k
    a.Serialize(os);
769
58.7k
}
void Serialize<VectorWriter, CInv>(T&, T0 const&)
Line
Count
Source
767
84.8k
{
768
84.8k
    a.Serialize(os);
769
84.8k
}
void Serialize<VectorWriter, ParamsWrapper<TransactionSerParams, CBlock const>>(T&, T0 const&)
Line
Count
Source
767
8.24k
{
768
8.24k
    a.Serialize(os);
769
8.24k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, CBlock>(T&, T0 const&)
Line
Count
Source
767
35.0k
{
768
35.0k
    a.Serialize(os);
769
35.0k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, CBlockHeader>(T&, T0 const&)
Line
Count
Source
767
35.0k
{
768
35.0k
    a.Serialize(os);
769
35.0k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, uint256>(T&, T0 const&)
Line
Count
Source
767
70.1k
{
768
70.1k
    a.Serialize(os);
769
70.1k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>>(T&, T0 const&)
Line
Count
Source
767
35.6k
{
768
35.6k
    a.Serialize(os);
769
35.6k
}
void Serialize<VectorWriter, CMerkleBlock>(T&, T0 const&)
Line
Count
Source
767
4
{
768
4
    a.Serialize(os);
769
4
}
void Serialize<VectorWriter, CPartialMerkleTree>(T&, T0 const&)
Line
Count
Source
767
4
{
768
4
    a.Serialize(os);
769
4
}
void Serialize<VectorWriter, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>> const&>>(T&, T0 const&)
Line
Count
Source
767
3.01k
{
768
3.01k
    a.Serialize(os);
769
3.01k
}
void Serialize<VectorWriter, CBlockLocator>(T&, T0 const&)
Line
Count
Source
767
3.01k
{
768
3.01k
    a.Serialize(os);
769
3.01k
}
void Serialize<VectorWriter, BlockTransactions>(T&, T0 const&)
Line
Count
Source
767
590
{
768
590
    a.Serialize(os);
769
590
}
void Serialize<VectorWriter, ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>>>(T&, T0 const&)
Line
Count
Source
767
590
{
768
590
    a.Serialize(os);
769
590
}
void Serialize<VectorWriter, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CBlockHeader, std::allocator<CBlockHeader>> const&>>(T&, T0 const&)
Line
Count
Source
767
9
{
768
9
    a.Serialize(os);
769
9
}
void Serialize<VectorWriter, ParamsWrapper<TransactionSerParams, std::vector<CBlock, std::allocator<CBlock>>>>(T&, T0 const&)
Line
Count
Source
767
5.27k
{
768
5.27k
    a.Serialize(os);
769
5.27k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CBlock, std::allocator<CBlock>> const&>>(T&, T0 const&)
Line
Count
Source
767
5.27k
{
768
5.27k
    a.Serialize(os);
769
5.27k
}
void Serialize<VectorWriter, BlockTransactionsRequest>(T&, T0 const&)
Line
Count
Source
767
577
{
768
577
    a.Serialize(os);
769
577
}
void Serialize<VectorWriter, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&>>(T&, T0 const&)
Line
Count
Source
767
577
{
768
577
    a.Serialize(os);
769
577
}
void Serialize<VectorWriter, BlockFilter>(T&, T0 const&)
Line
Count
Source
767
11
{
768
11
    a.Serialize(os);
769
11
}
void Serialize<VectorWriter, ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>>>>(T&, T0 const&)
Line
Count
Source
767
134
{
768
134
    a.Serialize(os);
769
134
}
void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>> const&>>(T&, T0 const&)
Line
Count
Source
767
134
{
768
134
    a.Serialize(os);
769
134
}
void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, CAddress>(T&, T0 const&)
Line
Count
Source
767
18.9k
{
768
18.9k
    a.Serialize(os);
769
18.9k
}
void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>>(T&, T0 const&)
Line
Count
Source
767
18.9k
{
768
18.9k
    a.Serialize(os);
769
18.9k
}
void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(T&, T0 const&)
Line
Count
Source
767
33
{
768
33
    a.Serialize(os);
769
33
}
void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>>(T&, T0 const&)
Line
Count
Source
767
18.9k
{
768
18.9k
    a.Serialize(os);
769
18.9k
}
void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService const>>(T&, T0 const&)
Line
Count
Source
767
18.9k
{
768
18.9k
    a.Serialize(os);
769
18.9k
}
void Serialize<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>, CService>(T&, T0 const&)
Line
Count
Source
767
18.9k
{
768
18.9k
    a.Serialize(os);
769
18.9k
}
void Serialize<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr>(T&, T0 const&)
Line
Count
Source
767
18.9k
{
768
18.9k
    a.Serialize(os);
769
18.9k
}
Unexecuted instantiation: void Serialize<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(T&, T0 const&)
void Serialize<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(T&, T0 const&)
Line
Count
Source
767
18.9k
{
768
18.9k
    a.Serialize(os);
769
18.9k
}
void Serialize<DataStream, kernel::CBlockFileInfo>(T&, T0 const&)
Line
Count
Source
767
1.72k
{
768
1.72k
    a.Serialize(os);
769
1.72k
}
void Serialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long const&>>(T&, T0 const&)
Line
Count
Source
767
3.44k
{
768
3.44k
    a.Serialize(os);
769
3.44k
}
void Serialize<DataStream, CDiskBlockIndex>(T&, T0 const&)
Line
Count
Source
767
117k
{
768
117k
    a.Serialize(os);
769
117k
}
void Serialize<SizeComputer, CBlockUndo>(T&, T0 const&)
Line
Count
Source
767
100k
{
768
100k
    a.Serialize(os);
769
100k
}
void Serialize<SizeComputer, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>> const&>>(T&, T0 const&)
Line
Count
Source
767
100k
{
768
100k
    a.Serialize(os);
769
100k
}
void Serialize<SizeComputer, CTxUndo>(T&, T0 const&)
Line
Count
Source
767
45.0k
{
768
45.0k
    a.Serialize(os);
769
45.0k
}
void Serialize<SizeComputer, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>>(T&, T0 const&)
Line
Count
Source
767
45.0k
{
768
45.0k
    a.Serialize(os);
769
45.0k
}
void Serialize<SizeComputer, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(T&, T0 const&)
Line
Count
Source
767
129k
{
768
129k
    a.Serialize(os);
769
129k
}
void Serialize<SizeComputer, Wrapper<TxOutCompression, CTxOut const&>>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<SizeComputer, Wrapper<AmountCompression, long const&>>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<SizeComputer, Wrapper<ScriptCompression, CScript const&>>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<HashWriter, CBlockUndo>(T&, T0 const&)
Line
Count
Source
767
100k
{
768
100k
    a.Serialize(os);
769
100k
}
void Serialize<HashWriter, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>> const&>>(T&, T0 const&)
Line
Count
Source
767
100k
{
768
100k
    a.Serialize(os);
769
100k
}
void Serialize<HashWriter, CTxUndo>(T&, T0 const&)
Line
Count
Source
767
45.0k
{
768
45.0k
    a.Serialize(os);
769
45.0k
}
void Serialize<HashWriter, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>>(T&, T0 const&)
Line
Count
Source
767
45.0k
{
768
45.0k
    a.Serialize(os);
769
45.0k
}
void Serialize<HashWriter, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(T&, T0 const&)
Line
Count
Source
767
129k
{
768
129k
    a.Serialize(os);
769
129k
}
void Serialize<HashWriter, Wrapper<TxOutCompression, CTxOut const&>>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<HashWriter, Wrapper<AmountCompression, long const&>>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<HashWriter, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<HashWriter, Wrapper<ScriptCompression, CScript const&>>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<BufferedWriter<AutoFile>, CBlockUndo>(T&, T0 const&)
Line
Count
Source
767
100k
{
768
100k
    a.Serialize(os);
769
100k
}
void Serialize<BufferedWriter<AutoFile>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>> const&>>(T&, T0 const&)
Line
Count
Source
767
100k
{
768
100k
    a.Serialize(os);
769
100k
}
void Serialize<BufferedWriter<AutoFile>, CTxUndo>(T&, T0 const&)
Line
Count
Source
767
45.0k
{
768
45.0k
    a.Serialize(os);
769
45.0k
}
void Serialize<BufferedWriter<AutoFile>, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>>(T&, T0 const&)
Line
Count
Source
767
45.0k
{
768
45.0k
    a.Serialize(os);
769
45.0k
}
void Serialize<BufferedWriter<AutoFile>, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(T&, T0 const&)
Line
Count
Source
767
129k
{
768
129k
    a.Serialize(os);
769
129k
}
void Serialize<BufferedWriter<AutoFile>, Wrapper<TxOutCompression, CTxOut const&>>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<BufferedWriter<AutoFile>, Wrapper<AmountCompression, long const&>>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<BufferedWriter<AutoFile>, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<BufferedWriter<AutoFile>, Wrapper<ScriptCompression, CScript const&>>(T&, T0 const&)
Line
Count
Source
767
69.5k
{
768
69.5k
    a.Serialize(os);
769
69.5k
}
void Serialize<BufferedWriter<AutoFile>, uint256>(T&, T0 const&)
Line
Count
Source
767
100k
{
768
100k
    a.Serialize(os);
769
100k
}
void Serialize<BufferedWriter<AutoFile>, ParamsWrapper<TransactionSerParams, CBlock const>>(T&, T0 const&)
Line
Count
Source
767
102k
{
768
102k
    a.Serialize(os);
769
102k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CBlock>(T&, T0 const&)
Line
Count
Source
767
102k
{
768
102k
    a.Serialize(os);
769
102k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CBlockHeader>(T&, T0 const&)
Line
Count
Source
767
102k
{
768
102k
    a.Serialize(os);
769
102k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, uint256>(T&, T0 const&)
Line
Count
Source
767
205k
{
768
205k
    a.Serialize(os);
769
205k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>>(T&, T0 const&)
Line
Count
Source
767
102k
{
768
102k
    a.Serialize(os);
769
102k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CTransaction>(T&, T0 const&)
Line
Count
Source
767
153k
{
768
153k
    a.Serialize(os);
769
153k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>>(T&, T0 const&)
Line
Count
Source
767
270k
{
768
270k
    a.Serialize(os);
769
270k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CTxIn>(T&, T0 const&)
Line
Count
Source
767
185k
{
768
185k
    a.Serialize(os);
769
185k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, COutPoint>(T&, T0 const&)
Line
Count
Source
767
185k
{
768
185k
    a.Serialize(os);
769
185k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, transaction_identifier<false>>(T&, T0 const&)
Line
Count
Source
767
185k
{
768
185k
    a.Serialize(os);
769
185k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CScript>(T&, T0 const&)
Line
Count
Source
767
567k
{
768
567k
    a.Serialize(os);
769
567k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>>(T&, T0 const&)
Line
Count
Source
767
153k
{
768
153k
    a.Serialize(os);
769
153k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CTxOut>(T&, T0 const&)
Line
Count
Source
767
381k
{
768
381k
    a.Serialize(os);
769
381k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>>(T&, T0 const&)
Line
Count
Source
767
141k
{
768
141k
    a.Serialize(os);
769
141k
}
void Serialize<AutoFile, Obfuscation>(T&, T0 const&)
Line
Count
Source
767
1.02k
{
768
1.02k
    a.Serialize(os);
769
1.02k
}
void Serialize<AutoFile, ParamsWrapper<TransactionSerParams, CTransaction const>>(T&, T0 const&)
Line
Count
Source
767
1.21k
{
768
1.21k
    a.Serialize(os);
769
1.21k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, CTransaction>(T&, T0 const&)
Line
Count
Source
767
1.21k
{
768
1.21k
    a.Serialize(os);
769
1.21k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>> const&>>(T&, T0 const&)
Line
Count
Source
767
2.35k
{
768
2.35k
    a.Serialize(os);
769
2.35k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, CTxIn>(T&, T0 const&)
Line
Count
Source
767
2.38k
{
768
2.38k
    a.Serialize(os);
769
2.38k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, COutPoint>(T&, T0 const&)
Line
Count
Source
767
2.38k
{
768
2.38k
    a.Serialize(os);
769
2.38k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, transaction_identifier<false>>(T&, T0 const&)
Line
Count
Source
767
2.38k
{
768
2.38k
    a.Serialize(os);
769
2.38k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, CScript>(T&, T0 const&)
Line
Count
Source
767
4.25k
{
768
4.25k
    a.Serialize(os);
769
4.25k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>> const&>>(T&, T0 const&)
Line
Count
Source
767
1.21k
{
768
1.21k
    a.Serialize(os);
769
1.21k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, CTxOut>(T&, T0 const&)
Line
Count
Source
767
1.87k
{
768
1.87k
    a.Serialize(os);
769
1.87k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&>>(T&, T0 const&)
Line
Count
Source
767
2.26k
{
768
2.26k
    a.Serialize(os);
769
2.26k
}
void Serialize<AutoFile, transaction_identifier<false>>(T&, T0 const&)
Line
Count
Source
767
7.36k
{
768
7.36k
    a.Serialize(os);
769
7.36k
}
block_policy_estimator.cpp:void Serialize<AutoFile, Wrapper<(anonymous namespace)::EncodedDoubleFormatter, double const&>>(T&, T0 const&)
Line
Count
Source
767
3.34k
{
768
3.34k
    a.Serialize(os);
769
3.34k
}
block_policy_estimator.cpp:void Serialize<AutoFile, Wrapper<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>, std::vector<double, std::allocator<double>> const&>>(T&, T0 const&)
Line
Count
Source
767
7.80k
{
768
7.80k
    a.Serialize(os);
769
7.80k
}
block_policy_estimator.cpp:void Serialize<AutoFile, Wrapper<VectorFormatter<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>> const&>>(T&, T0 const&)
Line
Count
Source
767
6.69k
{
768
6.69k
    a.Serialize(os);
769
6.69k
}
mempool_estimator.cpp:void Serialize<AutoFile, Wrapper<VectorFormatter<(anonymous namespace)::MinedBlockStatsFormatter>, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>> const&>>(T&, T0 const&)
Line
Count
Source
767
1.11k
{
768
1.11k
    a.Serialize(os);
769
1.11k
}
void Serialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CCoin, std::allocator<CCoin>> const&>>(T&, T0 const&)
Line
Count
Source
767
3
{
768
3
    a.Serialize(os);
769
3
}
void Serialize<DataStream, CCoin>(T&, T0 const&)
Line
Count
Source
767
2
{
768
2
    a.Serialize(os);
769
2
}
void Serialize<AutoFile, Coin>(T&, T0 const&)
Line
Count
Source
767
6.58k
{
768
6.58k
    a.Serialize(os);
769
6.58k
}
void Serialize<AutoFile, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(T&, T0 const&)
Line
Count
Source
767
7.05k
{
768
7.05k
    a.Serialize(os);
769
7.05k
}
void Serialize<AutoFile, Wrapper<TxOutCompression, CTxOut const&>>(T&, T0 const&)
Line
Count
Source
767
6.58k
{
768
6.58k
    a.Serialize(os);
769
6.58k
}
void Serialize<AutoFile, Wrapper<AmountCompression, long const&>>(T&, T0 const&)
Line
Count
Source
767
6.58k
{
768
6.58k
    a.Serialize(os);
769
6.58k
}
void Serialize<AutoFile, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>>(T&, T0 const&)
Line
Count
Source
767
6.58k
{
768
6.58k
    a.Serialize(os);
769
6.58k
}
void Serialize<AutoFile, Wrapper<ScriptCompression, CScript const&>>(T&, T0 const&)
Line
Count
Source
767
6.58k
{
768
6.58k
    a.Serialize(os);
769
6.58k
}
void Serialize<AutoFile, node::SnapshotMetadata>(T&, T0 const&)
Line
Count
Source
767
44
{
768
44
    a.Serialize(os);
769
44
}
void Serialize<DataStream, ParamsWrapper<TransactionSerParams, CBlock const>>(T&, T0 const&)
Line
Count
Source
767
5
{
768
5
    a.Serialize(os);
769
5
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, CBlock>(T&, T0 const&)
Line
Count
Source
767
5
{
768
5
    a.Serialize(os);
769
5
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, CBlockHeader>(T&, T0 const&)
Line
Count
Source
767
41
{
768
41
    a.Serialize(os);
769
41
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, uint256>(T&, T0 const&)
Line
Count
Source
767
84
{
768
84
    a.Serialize(os);
769
84
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>>(T&, T0 const&)
Line
Count
Source
767
41
{
768
41
    a.Serialize(os);
769
41
}
void Serialize<VectorWriter, CExtPubKey>(T&, T0 const&)
Line
Count
Source
767
156k
{
768
156k
    a.Serialize(os);
769
156k
}
void Serialize<VectorWriter, Wrapper<CustomUintFormatter<4, true>, unsigned int const&>>(T&, T0 const&)
Line
Count
Source
767
157k
{
768
157k
    a.Serialize(os);
769
157k
}
void Serialize<VectorWriter, ChainCode>(T&, T0 const&)
Line
Count
Source
767
157k
{
768
157k
    a.Serialize(os);
769
157k
}
txdb.cpp:void Serialize<DataStream, (anonymous namespace)::CoinEntry>(T&, T0 const&)
Line
Count
Source
767
5.62M
{
768
5.62M
    a.Serialize(os);
769
5.62M
}
void Serialize<DataStream, Coin>(T&, T0 const&)
Line
Count
Source
767
289k
{
768
289k
    a.Serialize(os);
769
289k
}
void Serialize<DataStream, Wrapper<TxOutCompression, CTxOut const&>>(T&, T0 const&)
Line
Count
Source
767
289k
{
768
289k
    a.Serialize(os);
769
289k
}
void Serialize<DataStream, Wrapper<AmountCompression, long const&>>(T&, T0 const&)
Line
Count
Source
767
289k
{
768
289k
    a.Serialize(os);
769
289k
}
void Serialize<DataStream, Wrapper<ScriptCompression, CScript const&>>(T&, T0 const&)
Line
Count
Source
767
289k
{
768
289k
    a.Serialize(os);
769
289k
}
void Serialize<HashWriter, CBlockHeader>(T&, T0 const&)
Line
Count
Source
767
18.6M
{
768
18.6M
    a.Serialize(os);
769
18.6M
}
void Serialize<HashWriter, ParamsWrapper<TransactionSerParams, CMutableTransaction const>>(T&, T0 const&)
Line
Count
Source
767
661k
{
768
661k
    a.Serialize(os);
769
661k
}
void Serialize<HashWriter, ParamsWrapper<TransactionSerParams, CTransaction const>>(T&, T0 const&)
Line
Count
Source
767
1.70M
{
768
1.70M
    a.Serialize(os);
769
1.70M
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, CTransaction>(T&, T0 const&)
Line
Count
Source
767
1.70M
{
768
1.70M
    a.Serialize(os);
769
1.70M
}
interpreter.cpp:void Serialize<HashWriter, (anonymous namespace)::CTransactionSignatureSerializer<CTransaction>>(T&, T0 const&)
Line
Count
Source
767
41.2k
{
768
41.2k
    a.Serialize(os);
769
41.2k
}
interpreter.cpp:void Serialize<HashWriter, (anonymous namespace)::CTransactionSignatureSerializer<CMutableTransaction>>(T&, T0 const&)
Line
Count
Source
767
86.2k
{
768
86.2k
    a.Serialize(os);
769
86.2k
}
void Serialize<HashWriter, CompactSizeWriter>(T&, T0 const&)
Line
Count
Source
767
163k
{
768
163k
    a.Serialize(os);
769
163k
}
void Serialize<DataStream, transaction_identifier<true>>(T&, T0 const&)
Line
Count
Source
767
18.2k
{
768
18.2k
    a.Serialize(os);
769
18.2k
}
void Serialize<DataStream, wallet::CKeyMetadata>(T&, T0 const&)
Line
Count
Source
767
60
{
768
60
    a.Serialize(os);
769
60
}
void Serialize<DataStream, CKeyID>(T&, T0 const&)
Line
Count
Source
767
60
{
768
60
    a.Serialize(os);
769
60
}
Unexecuted instantiation: void Serialize<DataStream, KeyOriginInfo>(T&, T0 const&)
Unexecuted instantiation: void Serialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<unsigned int, std::allocator<unsigned int>> const&>>(T&, T0 const&)
void Serialize<DataStream, wallet::CMasterKey>(T&, T0 const&)
Line
Count
Source
767
45
{
768
45
    a.Serialize(os);
769
45
}
void Serialize<DataStream, wallet::WalletDescriptor>(T&, T0 const&)
Line
Count
Source
767
103k
{
768
103k
    a.Serialize(os);
769
103k
}
void Serialize<SpanWriter, COutPoint>(T&, T0 const&)
Line
Count
Source
767
59
{
768
59
    a.Serialize(os);
769
59
}
void Serialize<SpanWriter, transaction_identifier<false>>(T&, T0 const&)
Line
Count
Source
767
59
{
768
59
    a.Serialize(os);
769
59
}
void Serialize<DataStream, ParamsWrapper<TransactionSerParams, CTransaction const>>(T&, T0 const&)
Line
Count
Source
767
57.1k
{
768
57.1k
    a.Serialize(os);
769
57.1k
}
void Serialize<VectorWriter, CExtKey>(T&, T0 const&)
Line
Count
Source
767
1.09k
{
768
1.09k
    a.Serialize(os);
769
1.09k
}
void Serialize<HashWriter, CPubKey>(T&, T0 const&)
Line
Count
Source
767
870
{
768
870
    a.Serialize(os);
769
870
}
770
771
template <class T, class Stream>
772
concept Unserializable = requires(T a, Stream s) { a.Unserialize(s); };
773
template <typename Stream, typename T>
774
    requires Unserializable<T, Stream>
775
void Unserialize(Stream& is, T&& a)
776
14.9M
{
777
14.9M
    a.Unserialize(is);
778
14.9M
}
void Unserialize<DataStream, AddrMan&>(T&, T0&&)
Line
Count
Source
776
7
{
777
7
    a.Unserialize(is);
778
7
}
void Unserialize<DataStream, CExtKey&>(T&, T0&&)
Line
Count
Source
776
95
{
777
95
    a.Unserialize(is);
778
95
}
void Unserialize<DataStream, Wrapper<CustomUintFormatter<4, true>, unsigned int&>&>(T&, T0&&)
Line
Count
Source
776
5.90k
{
777
5.90k
    a.Unserialize(is);
778
5.90k
}
void Unserialize<DataStream, ChainCode&>(T&, T0&&)
Line
Count
Source
776
5.89k
{
777
5.89k
    a.Unserialize(is);
778
5.89k
}
void Unserialize<DataStream, CExtPubKey&>(T&, T0&&)
Line
Count
Source
776
5.82k
{
777
5.82k
    a.Unserialize(is);
778
5.82k
}
void Unserialize<SpanReader, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>>(T&, T0&&)
Line
Count
Source
776
166
{
777
166
    a.Unserialize(is);
778
166
}
void Unserialize<DataStream, blockencodings_tests::TestHeaderAndShortIDs&>(T&, T0&&)
Line
Count
Source
776
2
{
777
2
    a.Unserialize(is);
778
2
}
void Unserialize<DataStream, CBlockHeader&>(T&, T0&&)
Line
Count
Source
776
476k
{
777
476k
    a.Unserialize(is);
778
476k
}
void Unserialize<DataStream, uint256&>(T&, T0&&)
Line
Count
Source
776
1.54M
{
777
1.54M
    a.Unserialize(is);
778
1.54M
}
void Unserialize<DataStream, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>>&>&>(T&, T0&&)
Line
Count
Source
776
21.6k
{
777
21.6k
    a.Unserialize(is);
778
21.6k
}
void Unserialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&>>(T&, T0&&)
Line
Count
Source
776
21.6k
{
777
21.6k
    a.Unserialize(is);
778
21.6k
}
void Unserialize<DataStream, PrefilledTransaction&>(T&, T0&&)
Line
Count
Source
776
21.6k
{
777
21.6k
    a.Unserialize(is);
778
21.6k
}
void Unserialize<DataStream, Wrapper<CompactSizeFormatter<true>, unsigned short&>&>(T&, T0&&)
Line
Count
Source
776
21.6k
{
777
21.6k
    a.Unserialize(is);
778
21.6k
}
void Unserialize<DataStream, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>>&>(T&, T0&&)
Line
Count
Source
776
21.6k
{
777
21.6k
    a.Unserialize(is);
778
21.6k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>&>(T&, T0&&)
Line
Count
Source
776
21.6k
{
777
21.6k
    a.Unserialize(is);
778
21.6k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>>(T&, T0&&)
Line
Count
Source
776
194k
{
777
194k
    a.Unserialize(is);
778
194k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, CTxIn&>(T&, T0&&)
Line
Count
Source
776
137k
{
777
137k
    a.Unserialize(is);
778
137k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, COutPoint&>(T&, T0&&)
Line
Count
Source
776
137k
{
777
137k
    a.Unserialize(is);
778
137k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, transaction_identifier<false>&>(T&, T0&&)
Line
Count
Source
776
137k
{
777
137k
    a.Unserialize(is);
778
137k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, CScript&>(T&, T0&&)
Line
Count
Source
776
426k
{
777
426k
    a.Unserialize(is);
778
426k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>>(T&, T0&&)
Line
Count
Source
776
115k
{
777
115k
    a.Unserialize(is);
778
115k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, CTxOut&>(T&, T0&&)
Line
Count
Source
776
289k
{
777
289k
    a.Unserialize(is);
778
289k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>>(T&, T0&&)
Line
Count
Source
776
94.2k
{
777
94.2k
    a.Unserialize(is);
778
94.2k
}
void Unserialize<DataStream, CBlockHeaderAndShortTxIDs&>(T&, T0&&)
Line
Count
Source
776
21.6k
{
777
21.6k
    a.Unserialize(is);
778
21.6k
}
void Unserialize<DataStream, BlockTransactionsRequest&>(T&, T0&&)
Line
Count
Source
776
597
{
777
597
    a.Unserialize(is);
778
597
}
void Unserialize<DataStream, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>>&>&>(T&, T0&&)
Line
Count
Source
776
597
{
777
597
    a.Unserialize(is);
778
597
}
void Unserialize<DataStream, BlockFilter&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>>(T&, T0&&)
Line
Count
Source
776
264
{
777
264
    a.Unserialize(is);
778
264
}
void Unserialize<DataStream, CTxIn&>(T&, T0&&)
Line
Count
Source
776
4.79k
{
777
4.79k
    a.Unserialize(is);
778
4.79k
}
void Unserialize<DataStream, COutPoint&>(T&, T0&&)
Line
Count
Source
776
4.79k
{
777
4.79k
    a.Unserialize(is);
778
4.79k
}
void Unserialize<DataStream, transaction_identifier<false>&>(T&, T0&&)
Line
Count
Source
776
16.2k
{
777
16.2k
    a.Unserialize(is);
778
16.2k
}
void Unserialize<DataStream, CScript&>(T&, T0&&)
Line
Count
Source
776
9.76k
{
777
9.76k
    a.Unserialize(is);
778
9.76k
}
void Unserialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>>(T&, T0&&)
Line
Count
Source
776
220
{
777
220
    a.Unserialize(is);
778
220
}
void Unserialize<DataStream, CTxOut&>(T&, T0&&)
Line
Count
Source
776
4.78k
{
777
4.78k
    a.Unserialize(is);
778
4.78k
}
void Unserialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>>(T&, T0&&)
Line
Count
Source
776
4.59k
{
777
4.59k
    a.Unserialize(is);
778
4.59k
}
void Unserialize<SpanReader, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<SpanReader, CTxIn&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<SpanReader, COutPoint&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<SpanReader, transaction_identifier<false>&>(T&, T0&&)
Line
Count
Source
776
281k
{
777
281k
    a.Unserialize(is);
778
281k
}
void Unserialize<SpanReader, CScript&>(T&, T0&&)
Line
Count
Source
776
8.14k
{
777
8.14k
    a.Unserialize(is);
778
8.14k
}
void Unserialize<SpanReader, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<SpanReader, CTxOut&>(T&, T0&&)
Line
Count
Source
776
4.78k
{
777
4.78k
    a.Unserialize(is);
778
4.78k
}
void Unserialize<DataStream, ParamsWrapper<TransactionSerParams, CBlock>&>(T&, T0&&)
Line
Count
Source
776
34.2k
{
777
34.2k
    a.Unserialize(is);
778
34.2k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, CBlock&>(T&, T0&&)
Line
Count
Source
776
34.2k
{
777
34.2k
    a.Unserialize(is);
778
34.2k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, CBlockHeader&>(T&, T0&&)
Line
Count
Source
776
34.2k
{
777
34.2k
    a.Unserialize(is);
778
34.2k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, uint256&>(T&, T0&&)
Line
Count
Source
776
68.4k
{
777
68.4k
    a.Unserialize(is);
778
68.4k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>>(T&, T0&&)
Line
Count
Source
776
34.2k
{
777
34.2k
    a.Unserialize(is);
778
34.2k
}
void Unserialize<SpanReader, Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned long>>&>&>(T&, T0&&)
Line
Count
Source
776
681
{
777
681
    a.Unserialize(is);
778
681
}
void Unserialize<SpanReader, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>&>(T&, T0&&)
Line
Count
Source
776
79.0k
{
777
79.0k
    a.Unserialize(is);
778
79.0k
}
void Unserialize<SpanReader, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
466k
{
777
466k
    a.Unserialize(is);
778
466k
}
void Unserialize<SpanReader, Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned int, 2u>>&>&>(T&, T0&&)
Line
Count
Source
776
681
{
777
681
    a.Unserialize(is);
778
681
}
void Unserialize<SpanReader, Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 8u>>&>&>(T&, T0&&)
Line
Count
Source
776
681
{
777
681
    a.Unserialize(is);
778
681
}
void Unserialize<SpanReader, Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::IntBitSet<unsigned int>>&>&>(T&, T0&&)
Line
Count
Source
776
396
{
777
396
    a.Unserialize(is);
778
396
}
void Unserialize<SpanReader, Wrapper<cluster_linearize::DepGraphFormatter, cluster_linearize::DepGraph<bitset_detail::MultiIntBitSet<unsigned char, 4u>>&>&>(T&, T0&&)
Line
Count
Source
776
375
{
777
375
    a.Unserialize(is);
778
375
}
void Unserialize<SpanReader, Coin&>(T&, T0&&)
Line
Count
Source
776
89.6k
{
777
89.6k
    a.Unserialize(is);
778
89.6k
}
void Unserialize<SpanReader, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(T&, T0&&)
Line
Count
Source
776
89.6k
{
777
89.6k
    a.Unserialize(is);
778
89.6k
}
void Unserialize<SpanReader, Wrapper<TxOutCompression, CTxOut&>>(T&, T0&&)
Line
Count
Source
776
89.6k
{
777
89.6k
    a.Unserialize(is);
778
89.6k
}
void Unserialize<SpanReader, Wrapper<AmountCompression, long&>&>(T&, T0&&)
Line
Count
Source
776
89.6k
{
777
89.6k
    a.Unserialize(is);
778
89.6k
}
void Unserialize<SpanReader, Wrapper<ScriptCompression, CScript&>&>(T&, T0&&)
Line
Count
Source
776
89.6k
{
777
89.6k
    a.Unserialize(is);
778
89.6k
}
void Unserialize<SpanReader, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&>(T&, T0&&)
Line
Count
Source
776
374k
{
777
374k
    a.Unserialize(is);
778
374k
}
void Unserialize<DataStream, MuHash3072&>(T&, T0&&)
Line
Count
Source
776
2
{
777
2
    a.Unserialize(is);
778
2
}
void Unserialize<DataStream, Num3072&>(T&, T0&&)
Line
Count
Source
776
4
{
777
4
    a.Unserialize(is);
778
4
}
void Unserialize<SpanReader, uint256&>(T&, T0&&)
Line
Count
Source
776
188k
{
777
188k
    a.Unserialize(is);
778
188k
}
void Unserialize<SpanReader, dbwrapper_tests::StringContentsSerializer&>(T&, T0&&)
Line
Count
Source
776
150
{
777
150
    a.Unserialize(is);
778
150
}
void Unserialize<AutoFile, Wrapper<LimitedStringFormatter<256ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>&>(T&, T0&&)
Line
Count
Source
776
4
{
777
4
    a.Unserialize(is);
778
4
}
void Unserialize<DataStream, CPubKey&>(T&, T0&&)
Line
Count
Source
776
3.68k
{
777
3.68k
    a.Unserialize(is);
778
3.68k
}
void Unserialize<DataStream, ParamsWrapper<CAddress::SerParams, CNetAddr>&>(T&, T0&&)
Line
Count
Source
776
20
{
777
20
    a.Unserialize(is);
778
20
}
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, CNetAddr&>(T&, T0&&)
Line
Count
Source
776
33
{
777
33
    a.Unserialize(is);
778
33
}
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
32
{
777
32
    a.Unserialize(is);
778
32
}
void Unserialize<SpanReader, ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>>>&>(T&, T0&&)
Line
Count
Source
776
3
{
777
3
    a.Unserialize(is);
778
3
}
void Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&>>(T&, T0&&)
Line
Count
Source
776
3
{
777
3
    a.Unserialize(is);
778
3
}
void Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>, CAddress&>(T&, T0&&)
Line
Count
Source
776
7
{
777
7
    a.Unserialize(is);
778
7
}
void Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(T&, T0&&)
Line
Count
Source
776
7
{
777
7
    a.Unserialize(is);
778
7
}
void Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
3
{
777
3
    a.Unserialize(is);
778
3
}
void Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&>(T&, T0&&)
Line
Count
Source
776
4
{
777
4
    a.Unserialize(is);
778
4
}
void Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>&>(T&, T0&&)
Line
Count
Source
776
7
{
777
7
    a.Unserialize(is);
778
7
}
void Unserialize<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>, CService&>(T&, T0&&)
Line
Count
Source
776
7
{
777
7
    a.Unserialize(is);
778
7
}
void Unserialize<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&>(T&, T0&&)
Line
Count
Source
776
7
{
777
7
    a.Unserialize(is);
778
7
}
void Unserialize<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
3
{
777
3
    a.Unserialize(is);
778
3
}
void Unserialize<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(T&, T0&&)
Line
Count
Source
776
7
{
777
7
    a.Unserialize(is);
778
7
}
void Unserialize<DataStream, CPartialMerkleTreeTester&>(T&, T0&&)
Line
Count
Source
776
168
{
777
168
    a.Unserialize(is);
778
168
}
void Unserialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>>(T&, T0&&)
Line
Count
Source
776
16.8k
{
777
16.8k
    a.Unserialize(is);
778
16.8k
}
void Unserialize<SpanReader, ParamsWrapper<TransactionSerParams, CMutableTransaction>&>(T&, T0&&)
Line
Count
Source
776
46.5k
{
777
46.5k
    a.Unserialize(is);
778
46.5k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, CMutableTransaction&>(T&, T0&&)
Line
Count
Source
776
46.5k
{
777
46.5k
    a.Unserialize(is);
778
46.5k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>>(T&, T0&&)
Line
Count
Source
776
449k
{
777
449k
    a.Unserialize(is);
778
449k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, CTxIn&>(T&, T0&&)
Line
Count
Source
776
332k
{
777
332k
    a.Unserialize(is);
778
332k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, COutPoint&>(T&, T0&&)
Line
Count
Source
776
332k
{
777
332k
    a.Unserialize(is);
778
332k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, transaction_identifier<false>&>(T&, T0&&)
Line
Count
Source
776
332k
{
777
332k
    a.Unserialize(is);
778
332k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, CScript&>(T&, T0&&)
Line
Count
Source
776
853k
{
777
853k
    a.Unserialize(is);
778
853k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>>(T&, T0&&)
Line
Count
Source
776
240k
{
777
240k
    a.Unserialize(is);
778
240k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, CTxOut&>(T&, T0&&)
Line
Count
Source
776
521k
{
777
521k
    a.Unserialize(is);
778
521k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>>(T&, T0&&)
Line
Count
Source
776
294k
{
777
294k
    a.Unserialize(is);
778
294k
}
void Unserialize<DataStream, Wrapper<LimitedVectorFormatter<0ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<DataStream, Wrapper<LimitedVectorFormatter<10ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<DataStream, Wrapper<LimitedVectorFormatter<12ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<DataStream, Wrapper<LimitedVectorFormatter<13ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<DataStream, Wrapper<LimitedVectorFormatter<14ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<DataStream, Wrapper<LimitedVectorFormatter<100ul, DefaultFormatter>, std::vector<int, std::allocator<int>>&>&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>&>(T&, T0&&)
Line
Count
Source
776
558k
{
777
558k
    a.Unserialize(is);
778
558k
}
void Unserialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
279k
{
777
279k
    a.Unserialize(is);
778
279k
}
void Unserialize<DataStream, serialize_tests::CSerializeMethodsTestMany&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<DataStream, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>&>(T&, T0&&)
Line
Count
Source
776
35.7k
{
777
35.7k
    a.Unserialize(is);
778
35.7k
}
void Unserialize<DataStream, serialize_tests::CSerializeMethodsTestSingle&>(T&, T0&&)
Line
Count
Source
776
2
{
777
2
    a.Unserialize(is);
778
2
}
void Unserialize<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>, serialize_tests::Base&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>, serialize_tests::OtherParamChecker const&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>, ParamsWrapper<serialize_tests::OtherParam, serialize_tests::OtherParamChecker const>&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>, serialize_tests::OtherParamChecker const&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::Base&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<DataStream, ParamsWrapper<serialize_tests::BaseFormat, serialize_tests::Base>&>(T&, T0&&)
Line
Count
Source
776
2
{
777
2
    a.Unserialize(is);
778
2
}
void Unserialize<ParamsStream<DataStream&, serialize_tests::BaseFormat>, serialize_tests::Base&>(T&, T0&&)
Line
Count
Source
776
6
{
777
6
    a.Unserialize(is);
778
6
}
void Unserialize<DataStream, ParamsWrapper<serialize_tests::BaseFormat, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>>&>(T&, T0&&)
Line
Count
Source
776
2
{
777
2
    a.Unserialize(is);
778
2
}
void Unserialize<ParamsStream<DataStream&, serialize_tests::BaseFormat>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>&>>(T&, T0&&)
Line
Count
Source
776
2
{
777
2
    a.Unserialize(is);
778
2
}
void Unserialize<SpanReader, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>&>(T&, T0&&)
Line
Count
Source
776
989
{
777
989
    a.Unserialize(is);
778
989
}
void Unserialize<DataStream, Obfuscation&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<DataStream, ParamsWrapper<TransactionSerParams, CMutableTransaction>&>(T&, T0&&)
Line
Count
Source
776
25
{
777
25
    a.Unserialize(is);
778
25
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, CMutableTransaction&>(T&, T0&&)
Line
Count
Source
776
25
{
777
25
    a.Unserialize(is);
778
25
}
void Unserialize<SpanReader, txindex::DBKey&>(T&, T0&&)
Line
Count
Source
776
326
{
777
326
    a.Unserialize(is);
778
326
}
void Unserialize<SpanReader, Wrapper<CustomUintFormatter<5, true>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
326
{
777
326
    a.Unserialize(is);
778
326
}
void Unserialize<SpanReader, txindex::BlockTxPosition&>(T&, T0&&)
Line
Count
Source
776
326
{
777
326
    a.Unserialize(is);
778
326
}
void Unserialize<SpanReader, Wrapper<CustomUintFormatter<3, true>, unsigned int&>&>(T&, T0&&)
Line
Count
Source
776
326
{
777
326
    a.Unserialize(is);
778
326
}
void Unserialize<DataStream, txindex::BlockTxPosition&>(T&, T0&&)
Line
Count
Source
776
4
{
777
4
    a.Unserialize(is);
778
4
}
void Unserialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&>(T&, T0&&)
Line
Count
Source
776
887k
{
777
887k
    a.Unserialize(is);
778
887k
}
void Unserialize<DataStream, Wrapper<CustomUintFormatter<3, true>, unsigned int&>&>(T&, T0&&)
Line
Count
Source
776
4
{
777
4
    a.Unserialize(is);
778
4
}
void Unserialize<SpanReader, CBlockLocator&>(T&, T0&&)
Line
Count
Source
776
110
{
777
110
    a.Unserialize(is);
778
110
}
void Unserialize<SpanReader, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<uint256, std::allocator<uint256>>&>>(T&, T0&&)
Line
Count
Source
776
130
{
777
130
    a.Unserialize(is);
778
130
}
void Unserialize<DataStream, uint160&>(T&, T0&&)
Line
Count
Source
776
89
{
777
89
    a.Unserialize(is);
778
89
}
void Unserialize<AutoFile, node::SnapshotMetadata&>(T&, T0&&)
Line
Count
Source
776
73
{
777
73
    a.Unserialize(is);
778
73
}
void Unserialize<AutoFile, uint256&>(T&, T0&&)
Line
Count
Source
776
2.77k
{
777
2.77k
    a.Unserialize(is);
778
2.77k
}
void Unserialize<AutoFile, transaction_identifier<false>&>(T&, T0&&)
Line
Count
Source
776
6.57k
{
777
6.57k
    a.Unserialize(is);
778
6.57k
}
void Unserialize<AutoFile, Coin&>(T&, T0&&)
Line
Count
Source
776
6.35k
{
777
6.35k
    a.Unserialize(is);
778
6.35k
}
void Unserialize<AutoFile, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(T&, T0&&)
Line
Count
Source
776
6.35k
{
777
6.35k
    a.Unserialize(is);
778
6.35k
}
void Unserialize<AutoFile, Wrapper<TxOutCompression, CTxOut&>>(T&, T0&&)
Line
Count
Source
776
6.35k
{
777
6.35k
    a.Unserialize(is);
778
6.35k
}
void Unserialize<AutoFile, Wrapper<AmountCompression, long&>&>(T&, T0&&)
Line
Count
Source
776
6.35k
{
777
6.35k
    a.Unserialize(is);
778
6.35k
}
void Unserialize<AutoFile, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
6.35k
{
777
6.35k
    a.Unserialize(is);
778
6.35k
}
void Unserialize<AutoFile, Wrapper<ScriptCompression, CScript&>&>(T&, T0&&)
Line
Count
Source
776
6.35k
{
777
6.35k
    a.Unserialize(is);
778
6.35k
}
void Unserialize<AutoFile, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&>(T&, T0&&)
Line
Count
Source
776
6.35k
{
777
6.35k
    a.Unserialize(is);
778
6.35k
}
Unexecuted instantiation: void Unserialize<DataStream, CompactSizeReader&>(T&, T0&&)
void Unserialize<SpanReader, CExtPubKey&>(T&, T0&&)
Line
Count
Source
776
8.45k
{
777
8.45k
    a.Unserialize(is);
778
8.45k
}
void Unserialize<SpanReader, Wrapper<CustomUintFormatter<4, true>, unsigned int&>&>(T&, T0&&)
Line
Count
Source
776
9.39k
{
777
9.39k
    a.Unserialize(is);
778
9.39k
}
void Unserialize<SpanReader, ChainCode&>(T&, T0&&)
Line
Count
Source
776
9.39k
{
777
9.39k
    a.Unserialize(is);
778
9.39k
}
void Unserialize<DataStream, PSBTInput&>(T&, T0&&)
Line
Count
Source
776
2
{
777
2
    a.Unserialize(is);
778
2
}
void Unserialize<SpanReader, XOnlyPubKey&>(T&, T0&&)
Line
Count
Source
776
8.15k
{
777
8.15k
    a.Unserialize(is);
778
8.15k
}
Unexecuted instantiation: void Unserialize<DataStream, XOnlyPubKey&>(T&, T0&&)
void Unserialize<DataStream, PSBTOutput&>(T&, T0&&)
Line
Count
Source
776
2
{
777
2
    a.Unserialize(is);
778
2
}
void Unserialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&>>(T&, T0&&)
Line
Count
Source
776
11.4k
{
777
11.4k
    a.Unserialize(is);
778
11.4k
}
Unexecuted instantiation: void Unserialize<DataStream, wallet::CMerkleTx&>(T&, T0&&)
void Unserialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&>>(T&, T0&&)
Line
Count
Source
776
11.4k
{
777
11.4k
    a.Unserialize(is);
778
11.4k
}
void Unserialize<HashVerifier<DataStream>, AddrMan&>(T&, T0&&)
Line
Count
Source
776
2
{
777
2
    a.Unserialize(is);
778
2
}
void Unserialize<HashVerifier<AutoFile>, AddrMan&>(T&, T0&&)
Line
Count
Source
776
639
{
777
639
    a.Unserialize(is);
778
639
}
void Unserialize<HashVerifier<AutoFile>, ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>>>&>(T&, T0&&)
Line
Count
Source
776
31
{
777
31
    a.Unserialize(is);
778
31
}
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&>>(T&, T0&&)
Line
Count
Source
776
31
{
777
31
    a.Unserialize(is);
778
31
}
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, CAddress&>(T&, T0&&)
Line
Count
Source
776
20.5k
{
777
20.5k
    a.Unserialize(is);
778
20.5k
}
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(T&, T0&&)
Line
Count
Source
776
20.5k
{
777
20.5k
    a.Unserialize(is);
778
20.5k
}
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
20.5k
{
777
20.5k
    a.Unserialize(is);
778
20.5k
}
Unexecuted instantiation: void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&>(T&, T0&&)
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>&>(T&, T0&&)
Line
Count
Source
776
20.5k
{
777
20.5k
    a.Unserialize(is);
778
20.5k
}
void Unserialize<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, CService&>(T&, T0&&)
Line
Count
Source
776
20.5k
{
777
20.5k
    a.Unserialize(is);
778
20.5k
}
void Unserialize<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&>(T&, T0&&)
Line
Count
Source
776
20.5k
{
777
20.5k
    a.Unserialize(is);
778
20.5k
}
void Unserialize<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
20.5k
{
777
20.5k
    a.Unserialize(is);
778
20.5k
}
void Unserialize<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(T&, T0&&)
Line
Count
Source
776
20.5k
{
777
20.5k
    a.Unserialize(is);
778
20.5k
}
Unexecuted instantiation: void Unserialize<AutoFile, Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&>&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>, uint256&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>, AddrInfo&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>, CAddress&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>, CService&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long&>&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>, CNetAddr&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long&>&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(T&, T0&&)
void Unserialize<HashVerifier<AutoFile>, Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&>&>(T&, T0&&)
Line
Count
Source
776
639
{
777
639
    a.Unserialize(is);
778
639
}
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, uint256&>(T&, T0&&)
Line
Count
Source
776
1.26k
{
777
1.26k
    a.Unserialize(is);
778
1.26k
}
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, AddrInfo&>(T&, T0&&)
Line
Count
Source
776
20.5k
{
777
20.5k
    a.Unserialize(is);
778
20.5k
}
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, CNetAddr&>(T&, T0&&)
Line
Count
Source
776
20.5k
{
777
20.5k
    a.Unserialize(is);
778
20.5k
}
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
20.5k
{
777
20.5k
    a.Unserialize(is);
778
20.5k
}
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(T&, T0&&)
Line
Count
Source
776
20.5k
{
777
20.5k
    a.Unserialize(is);
778
20.5k
}
void Unserialize<DataStream, Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&>&>(T&, T0&&)
Line
Count
Source
776
7
{
777
7
    a.Unserialize(is);
778
7
}
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, uint256&>(T&, T0&&)
Line
Count
Source
776
13
{
777
13
    a.Unserialize(is);
778
13
}
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, AddrInfo&>(T&, T0&&)
Line
Count
Source
776
14
{
777
14
    a.Unserialize(is);
778
14
}
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, CAddress&>(T&, T0&&)
Line
Count
Source
776
6.92k
{
777
6.92k
    a.Unserialize(is);
778
6.92k
}
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(T&, T0&&)
Line
Count
Source
776
6.91k
{
777
6.91k
    a.Unserialize(is);
778
6.91k
}
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
1.03k
{
777
1.03k
    a.Unserialize(is);
778
1.03k
}
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&>(T&, T0&&)
Line
Count
Source
776
5.88k
{
777
5.88k
    a.Unserialize(is);
778
5.88k
}
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>&>(T&, T0&&)
Line
Count
Source
776
6.91k
{
777
6.91k
    a.Unserialize(is);
778
6.91k
}
void Unserialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, CService&>(T&, T0&&)
Line
Count
Source
776
6.91k
{
777
6.91k
    a.Unserialize(is);
778
6.91k
}
void Unserialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&>(T&, T0&&)
Line
Count
Source
776
6.91k
{
777
6.91k
    a.Unserialize(is);
778
6.91k
}
void Unserialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
1.03k
{
777
1.03k
    a.Unserialize(is);
778
1.03k
}
void Unserialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(T&, T0&&)
Line
Count
Source
776
6.91k
{
777
6.91k
    a.Unserialize(is);
778
6.91k
}
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(T&, T0&&)
Line
Count
Source
776
13
{
777
13
    a.Unserialize(is);
778
13
}
void Unserialize<HashVerifier<DataStream>, Wrapper<CustomUintFormatter<1, false>, AddrManImpl::Format&>&>(T&, T0&&)
Line
Count
Source
776
2
{
777
2
    a.Unserialize(is);
778
2
}
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, uint256&>(T&, T0&&)
Line
Count
Source
776
3
{
777
3
    a.Unserialize(is);
778
3
}
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, AddrInfo&>(T&, T0&&)
Line
Count
Source
776
5
{
777
5
    a.Unserialize(is);
778
5
}
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, CAddress&>(T&, T0&&)
Line
Count
Source
776
5
{
777
5
    a.Unserialize(is);
778
5
}
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(T&, T0&&)
Line
Count
Source
776
4
{
777
4
    a.Unserialize(is);
778
4
}
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
3
{
777
3
    a.Unserialize(is);
778
3
}
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&>(T&, T0&&)
Line
Count
Source
776
1
{
777
1
    a.Unserialize(is);
778
1
}
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>&>(T&, T0&&)
Line
Count
Source
776
4
{
777
4
    a.Unserialize(is);
778
4
}
void Unserialize<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>, CService&>(T&, T0&&)
Line
Count
Source
776
4
{
777
4
    a.Unserialize(is);
778
4
}
void Unserialize<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&>(T&, T0&&)
Line
Count
Source
776
4
{
777
4
    a.Unserialize(is);
778
4
}
void Unserialize<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
3
{
777
3
    a.Unserialize(is);
778
3
}
void Unserialize<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(T&, T0&&)
Line
Count
Source
776
4
{
777
4
    a.Unserialize(is);
778
4
}
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, CNetAddr&>(T&, T0&&)
Line
Count
Source
776
4
{
777
4
    a.Unserialize(is);
778
4
}
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
3
{
777
3
    a.Unserialize(is);
778
3
}
void Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(T&, T0&&)
Line
Count
Source
776
4
{
777
4
    a.Unserialize(is);
778
4
}
void Unserialize<SpanReader, Obfuscation&>(T&, T0&&)
Line
Count
Source
776
936
{
777
936
    a.Unserialize(is);
778
936
}
void Unserialize<SpanReader, index_util::DBHeightKey&>(T&, T0&&)
Line
Count
Source
776
3.09k
{
777
3.09k
    a.Unserialize(is);
778
3.09k
}
blockfilterindex.cpp:void Unserialize<DataStream, (anonymous namespace)::DBVal&>(T&, T0&&)
Line
Count
Source
776
2.97k
{
777
2.97k
    a.Unserialize(is);
778
2.97k
}
void Unserialize<DataStream, FlatFilePos&>(T&, T0&&)
Line
Count
Source
776
2.97k
{
777
2.97k
    a.Unserialize(is);
778
2.97k
}
blockfilterindex.cpp:void Unserialize<SpanReader, (anonymous namespace)::DBVal&>(T&, T0&&)
Line
Count
Source
776
1.06k
{
777
1.06k
    a.Unserialize(is);
778
1.06k
}
void Unserialize<SpanReader, FlatFilePos&>(T&, T0&&)
Line
Count
Source
776
1.12k
{
777
1.12k
    a.Unserialize(is);
778
1.12k
}
coinstatsindex.cpp:void Unserialize<DataStream, (anonymous namespace)::DBVal&>(T&, T0&&)
Line
Count
Source
776
121
{
777
121
    a.Unserialize(is);
778
121
}
coinstatsindex.cpp:void Unserialize<SpanReader, (anonymous namespace)::DBVal&>(T&, T0&&)
Line
Count
Source
776
224
{
777
224
    a.Unserialize(is);
778
224
}
void Unserialize<SpanReader, MuHash3072&>(T&, T0&&)
Line
Count
Source
776
32
{
777
32
    a.Unserialize(is);
778
32
}
void Unserialize<SpanReader, Num3072&>(T&, T0&&)
Line
Count
Source
776
64
{
777
64
    a.Unserialize(is);
778
64
}
void Unserialize<AutoFile, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>&>(T&, T0&&)
Line
Count
Source
776
500
{
777
500
    a.Unserialize(is);
778
500
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>>(T&, T0&&)
Line
Count
Source
776
972
{
777
972
    a.Unserialize(is);
778
972
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, CTxIn&>(T&, T0&&)
Line
Count
Source
776
517
{
777
517
    a.Unserialize(is);
778
517
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, COutPoint&>(T&, T0&&)
Line
Count
Source
776
517
{
777
517
    a.Unserialize(is);
778
517
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, transaction_identifier<false>&>(T&, T0&&)
Line
Count
Source
776
517
{
777
517
    a.Unserialize(is);
778
517
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, CScript&>(T&, T0&&)
Line
Count
Source
776
1.34k
{
777
1.34k
    a.Unserialize(is);
778
1.34k
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>>(T&, T0&&)
Line
Count
Source
776
500
{
777
500
    a.Unserialize(is);
778
500
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, CTxOut&>(T&, T0&&)
Line
Count
Source
776
832
{
777
832
    a.Unserialize(is);
778
832
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>>(T&, T0&&)
Line
Count
Source
776
489
{
777
489
    a.Unserialize(is);
778
489
}
void Unserialize<SpanReader, CDiskTxPos&>(T&, T0&&)
Line
Count
Source
776
29
{
777
29
    a.Unserialize(is);
778
29
}
void Unserialize<AutoFile, CBlockHeader&>(T&, T0&&)
Line
Count
Source
776
24
{
777
24
    a.Unserialize(is);
778
24
}
void Unserialize<SpanReader, DBKey&>(T&, T0&&)
Line
Count
Source
776
26
{
777
26
    a.Unserialize(is);
778
26
}
Unexecuted instantiation: void Unserialize<ParamsStream<SpanReader, CAddress::SerParams>, CService&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<SpanReader, CAddress::SerParams>, CNetAddr&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<SpanReader, CAddress::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long&>&>(T&, T0&&)
Unexecuted instantiation: void Unserialize<ParamsStream<SpanReader, CAddress::SerParams>, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(T&, T0&&)
void Unserialize<DataStream, CMessageHeader&>(T&, T0&&)
Line
Count
Source
776
129k
{
777
129k
    a.Unserialize(is);
778
129k
}
void Unserialize<DataStream, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&>(T&, T0&&)
Line
Count
Source
776
1.73k
{
777
1.73k
    a.Unserialize(is);
778
1.73k
}
void Unserialize<DataStream, ParamsWrapper<CNetAddr::SerParams, CService>&>(T&, T0&&)
Line
Count
Source
776
1.73k
{
777
1.73k
    a.Unserialize(is);
778
1.73k
}
void Unserialize<ParamsStream<DataStream&, CNetAddr::SerParams>, CService&>(T&, T0&&)
Line
Count
Source
776
1.73k
{
777
1.73k
    a.Unserialize(is);
778
1.73k
}
void Unserialize<ParamsStream<DataStream&, CNetAddr::SerParams>, CNetAddr&>(T&, T0&&)
Line
Count
Source
776
1.73k
{
777
1.73k
    a.Unserialize(is);
778
1.73k
}
Unexecuted instantiation: void Unserialize<ParamsStream<DataStream&, CNetAddr::SerParams>, Wrapper<CompactSizeFormatter<true>, unsigned long&>&>(T&, T0&&)
void Unserialize<ParamsStream<DataStream&, CNetAddr::SerParams>, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(T&, T0&&)
Line
Count
Source
776
1.73k
{
777
1.73k
    a.Unserialize(is);
778
1.73k
}
void Unserialize<DataStream, Wrapper<LimitedStringFormatter<256ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>&>(T&, T0&&)
Line
Count
Source
776
1.70k
{
777
1.70k
    a.Unserialize(is);
778
1.70k
}
void Unserialize<DataStream, Wrapper<LimitedStringFormatter<80ul>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>&>(T&, T0&&)
Line
Count
Source
776
56
{
777
56
    a.Unserialize(is);
778
56
}
void Unserialize<DataStream, Wrapper<LimitedVectorFormatter<512ul, DefaultFormatter>, std::vector<unsigned char, std::allocator<unsigned char>>&>&>(T&, T0&&)
Line
Count
Source
776
52
{
777
52
    a.Unserialize(is);
778
52
}
void Unserialize<DataStream, ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>>>&>(T&, T0&&)
Line
Count
Source
776
58
{
777
58
    a.Unserialize(is);
778
58
}
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CAddress, std::allocator<CAddress>>&>>(T&, T0&&)
Line
Count
Source
776
58
{
777
58
    a.Unserialize(is);
778
58
}
void Unserialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CInv, std::allocator<CInv>>&>>(T&, T0&&)
Line
Count
Source
776
39.1k
{
777
39.1k
    a.Unserialize(is);
778
39.1k
}
void Unserialize<DataStream, CInv&>(T&, T0&&)
Line
Count
Source
776
167k
{
777
167k
    a.Unserialize(is);
778
167k
}
void Unserialize<DataStream, CBlockLocator&>(T&, T0&&)
Line
Count
Source
776
5.20k
{
777
5.20k
    a.Unserialize(is);
778
5.20k
}
void Unserialize<DataStream, BlockTransactions&>(T&, T0&&)
Line
Count
Source
776
572
{
777
572
    a.Unserialize(is);
778
572
}
void Unserialize<DataStream, ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>>&>(T&, T0&&)
Line
Count
Source
776
572
{
777
572
    a.Unserialize(is);
778
572
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>&>(T&, T0&&)
Line
Count
Source
776
572
{
777
572
    a.Unserialize(is);
778
572
}
void Unserialize<DataStream, CBloomFilter&>(T&, T0&&)
Line
Count
Source
776
10
{
777
10
    a.Unserialize(is);
778
10
}
void Unserialize<SpanReader, kernel::CBlockFileInfo&>(T&, T0&&)
Line
Count
Source
776
839
{
777
839
    a.Unserialize(is);
778
839
}
void Unserialize<DataStream, CDiskBlockIndex&>(T&, T0&&)
Line
Count
Source
776
152k
{
777
152k
    a.Unserialize(is);
778
152k
}
void Unserialize<HashVerifier<BufferedReader<AutoFile>>, CBlockUndo&>(T&, T0&&)
Line
Count
Source
776
33.7k
{
777
33.7k
    a.Unserialize(is);
778
33.7k
}
void Unserialize<HashVerifier<BufferedReader<AutoFile>>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxUndo, std::allocator<CTxUndo>>&>>(T&, T0&&)
Line
Count
Source
776
33.7k
{
777
33.7k
    a.Unserialize(is);
778
33.7k
}
void Unserialize<HashVerifier<BufferedReader<AutoFile>>, CTxUndo&>(T&, T0&&)
Line
Count
Source
776
21.0k
{
777
21.0k
    a.Unserialize(is);
778
21.0k
}
void Unserialize<HashVerifier<BufferedReader<AutoFile>>, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>>&>&>(T&, T0&&)
Line
Count
Source
776
21.0k
{
777
21.0k
    a.Unserialize(is);
778
21.0k
}
void Unserialize<HashVerifier<BufferedReader<AutoFile>>, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(T&, T0&&)
Line
Count
Source
776
62.2k
{
777
62.2k
    a.Unserialize(is);
778
62.2k
}
void Unserialize<HashVerifier<BufferedReader<AutoFile>>, Wrapper<TxOutCompression, CTxOut&>>(T&, T0&&)
Line
Count
Source
776
31.1k
{
777
31.1k
    a.Unserialize(is);
778
31.1k
}
void Unserialize<HashVerifier<BufferedReader<AutoFile>>, Wrapper<AmountCompression, long&>&>(T&, T0&&)
Line
Count
Source
776
31.1k
{
777
31.1k
    a.Unserialize(is);
778
31.1k
}
void Unserialize<HashVerifier<BufferedReader<AutoFile>>, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>&>(T&, T0&&)
Line
Count
Source
776
31.1k
{
777
31.1k
    a.Unserialize(is);
778
31.1k
}
void Unserialize<HashVerifier<BufferedReader<AutoFile>>, Wrapper<ScriptCompression, CScript&>&>(T&, T0&&)
Line
Count
Source
776
31.1k
{
777
31.1k
    a.Unserialize(is);
778
31.1k
}
void Unserialize<HashVerifier<BufferedReader<AutoFile>>, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&>(T&, T0&&)
Line
Count
Source
776
31.1k
{
777
31.1k
    a.Unserialize(is);
778
31.1k
}
void Unserialize<BufferedReader<AutoFile>, uint256&>(T&, T0&&)
Line
Count
Source
776
33.7k
{
777
33.7k
    a.Unserialize(is);
778
33.7k
}
void Unserialize<SpanReader, ParamsWrapper<TransactionSerParams, CBlock>&>(T&, T0&&)
Line
Count
Source
776
139k
{
777
139k
    a.Unserialize(is);
778
139k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, CBlock&>(T&, T0&&)
Line
Count
Source
776
139k
{
777
139k
    a.Unserialize(is);
778
139k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, CBlockHeader&>(T&, T0&&)
Line
Count
Source
776
140k
{
777
140k
    a.Unserialize(is);
778
140k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, uint256&>(T&, T0&&)
Line
Count
Source
776
280k
{
777
280k
    a.Unserialize(is);
778
280k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>>(T&, T0&&)
Line
Count
Source
776
140k
{
777
140k
    a.Unserialize(is);
778
140k
}
void Unserialize<AutoFile, Obfuscation&>(T&, T0&&)
Line
Count
Source
776
511
{
777
511
    a.Unserialize(is);
778
511
}
block_policy_estimator.cpp:void Unserialize<AutoFile, Wrapper<(anonymous namespace)::EncodedDoubleFormatter, double&>&>(T&, T0&&)
Line
Count
Source
776
1.74k
{
777
1.74k
    a.Unserialize(is);
778
1.74k
}
block_policy_estimator.cpp:void Unserialize<AutoFile, Wrapper<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>, std::vector<double, std::allocator<double>>&>&>(T&, T0&&)
Line
Count
Source
776
4.07k
{
777
4.07k
    a.Unserialize(is);
778
4.07k
}
block_policy_estimator.cpp:void Unserialize<AutoFile, Wrapper<VectorFormatter<VectorFormatter<(anonymous namespace)::EncodedDoubleFormatter>>, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>&>&>(T&, T0&&)
Line
Count
Source
776
3.49k
{
777
3.49k
    a.Unserialize(is);
778
3.49k
}
mempool_estimator.cpp:void Unserialize<AutoFile, Wrapper<VectorFormatter<(anonymous namespace)::MinedBlockStatsFormatter>, std::vector<MinedBlockStats, std::allocator<MinedBlockStats>>&>&>(T&, T0&&)
Line
Count
Source
776
587
{
777
587
    a.Unserialize(is);
778
587
}
void Unserialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<COutPoint, std::allocator<COutPoint>>&>>(T&, T0&&)
Line
Count
Source
776
2
{
777
2
    a.Unserialize(is);
778
2
}
void Unserialize<SpanReader, CMerkleBlock&>(T&, T0&&)
Line
Count
Source
776
20
{
777
20
    a.Unserialize(is);
778
20
}
void Unserialize<SpanReader, CBlockHeader&>(T&, T0&&)
Line
Count
Source
776
1.86k
{
777
1.86k
    a.Unserialize(is);
778
1.86k
}
void Unserialize<SpanReader, CPartialMerkleTree&>(T&, T0&&)
Line
Count
Source
776
20
{
777
20
    a.Unserialize(is);
778
20
}
txdb.cpp:void Unserialize<SpanReader, (anonymous namespace)::CoinEntry&>(T&, T0&&)
Line
Count
Source
776
279k
{
777
279k
    a.Unserialize(is);
778
279k
}
void Unserialize<DataStream, Coin&>(T&, T0&&)
Line
Count
Source
776
279k
{
777
279k
    a.Unserialize(is);
778
279k
}
void Unserialize<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(T&, T0&&)
Line
Count
Source
776
279k
{
777
279k
    a.Unserialize(is);
778
279k
}
void Unserialize<DataStream, Wrapper<TxOutCompression, CTxOut&>>(T&, T0&&)
Line
Count
Source
776
279k
{
777
279k
    a.Unserialize(is);
778
279k
}
void Unserialize<DataStream, Wrapper<AmountCompression, long&>&>(T&, T0&&)
Line
Count
Source
776
279k
{
777
279k
    a.Unserialize(is);
778
279k
}
void Unserialize<DataStream, Wrapper<ScriptCompression, CScript&>&>(T&, T0&&)
Line
Count
Source
776
279k
{
777
279k
    a.Unserialize(is);
778
279k
}
void Unserialize<BufferedFile, CBlockHeader&>(T&, T0&&)
Line
Count
Source
776
2.02k
{
777
2.02k
    a.Unserialize(is);
778
2.02k
}
void Unserialize<BufferedFile, uint256&>(T&, T0&&)
Line
Count
Source
776
4.05k
{
777
4.05k
    a.Unserialize(is);
778
4.05k
}
void Unserialize<BufferedFile, ParamsWrapper<TransactionSerParams, CBlock>&>(T&, T0&&)
Line
Count
Source
776
1.91k
{
777
1.91k
    a.Unserialize(is);
778
1.91k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, CBlock&>(T&, T0&&)
Line
Count
Source
776
1.91k
{
777
1.91k
    a.Unserialize(is);
778
1.91k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, CBlockHeader&>(T&, T0&&)
Line
Count
Source
776
1.91k
{
777
1.91k
    a.Unserialize(is);
778
1.91k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, uint256&>(T&, T0&&)
Line
Count
Source
776
3.83k
{
777
3.83k
    a.Unserialize(is);
778
3.83k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>>(T&, T0&&)
Line
Count
Source
776
1.91k
{
777
1.91k
    a.Unserialize(is);
778
1.91k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxIn, std::allocator<CTxIn>>&>>(T&, T0&&)
Line
Count
Source
776
3.98k
{
777
3.98k
    a.Unserialize(is);
778
3.98k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, CTxIn&>(T&, T0&&)
Line
Count
Source
776
2.01k
{
777
2.01k
    a.Unserialize(is);
778
2.01k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, COutPoint&>(T&, T0&&)
Line
Count
Source
776
2.01k
{
777
2.01k
    a.Unserialize(is);
778
2.01k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, transaction_identifier<false>&>(T&, T0&&)
Line
Count
Source
776
2.01k
{
777
2.01k
    a.Unserialize(is);
778
2.01k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, CScript&>(T&, T0&&)
Line
Count
Source
776
5.97k
{
777
5.97k
    a.Unserialize(is);
778
5.97k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<CTxOut, std::allocator<CTxOut>>&>>(T&, T0&&)
Line
Count
Source
776
2.01k
{
777
2.01k
    a.Unserialize(is);
778
2.01k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, CTxOut&>(T&, T0&&)
Line
Count
Source
776
3.96k
{
777
3.96k
    a.Unserialize(is);
778
3.96k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>>(T&, T0&&)
Line
Count
Source
776
1.97k
{
777
1.97k
    a.Unserialize(is);
778
1.97k
}
void Unserialize<AutoFile, wallet::MetaPage&>(T&, T0&&)
Line
Count
Source
776
104
{
777
104
    a.Unserialize(is);
778
104
}
void Unserialize<AutoFile, wallet::PageHeader&>(T&, T0&&)
Line
Count
Source
776
247
{
777
247
    a.Unserialize(is);
778
247
}
void Unserialize<AutoFile, wallet::RecordsPage&>(T&, T0&&)
Line
Count
Source
776
177
{
777
177
    a.Unserialize(is);
778
177
}
void Unserialize<AutoFile, wallet::RecordHeader&>(T&, T0&&)
Line
Count
Source
776
4.22k
{
777
4.22k
    a.Unserialize(is);
778
4.22k
}
void Unserialize<AutoFile, wallet::DataRecord&>(T&, T0&&)
Line
Count
Source
776
4.13k
{
777
4.13k
    a.Unserialize(is);
778
4.13k
}
Unexecuted instantiation: void Unserialize<AutoFile, wallet::OverflowRecord&>(T&, T0&&)
void Unserialize<AutoFile, wallet::InternalPage&>(T&, T0&&)
Line
Count
Source
776
18
{
777
18
    a.Unserialize(is);
778
18
}
void Unserialize<AutoFile, wallet::InternalRecord&>(T&, T0&&)
Line
Count
Source
776
91
{
777
91
    a.Unserialize(is);
778
91
}
Unexecuted instantiation: void Unserialize<AutoFile, wallet::OverflowPage&>(T&, T0&&)
void Unserialize<DataStream, wallet::CKeyMetadata&>(T&, T0&&)
Line
Count
Source
776
376
{
777
376
    a.Unserialize(is);
778
376
}
void Unserialize<DataStream, CKeyID&>(T&, T0&&)
Line
Count
Source
776
414
{
777
414
    a.Unserialize(is);
778
414
}
void Unserialize<DataStream, KeyOriginInfo&>(T&, T0&&)
Line
Count
Source
776
277
{
777
277
    a.Unserialize(is);
778
277
}
void Unserialize<DataStream, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<unsigned int, std::allocator<unsigned int>>&>>(T&, T0&&)
Line
Count
Source
776
277
{
777
277
    a.Unserialize(is);
778
277
}
void Unserialize<DataStream, wallet::CMasterKey&>(T&, T0&&)
Line
Count
Source
776
27
{
777
27
    a.Unserialize(is);
778
27
}
void Unserialize<DataStream, wallet::CHDChain&>(T&, T0&&)
Line
Count
Source
776
38
{
777
38
    a.Unserialize(is);
778
38
}
void Unserialize<SpanReader, CExtKey&>(T&, T0&&)
Line
Count
Source
776
939
{
777
939
    a.Unserialize(is);
778
939
}
void Unserialize<SpanReader, CompactSizeReader&>(T&, T0&&)
Line
Count
Source
776
3.30k
{
777
3.30k
    a.Unserialize(is);
778
3.30k
}
void Unserialize<SpanReader, PSBTInput&>(T&, T0&&)
Line
Count
Source
776
261
{
777
261
    a.Unserialize(is);
778
261
}
void Unserialize<SpanReader, PSBTOutput&>(T&, T0&&)
Line
Count
Source
776
211
{
777
211
    a.Unserialize(is);
778
211
}
779
780
/** Default formatter. Serializes objects as themselves.
781
 *
782
 * The vector/prevector serialization code passes this to VectorFormatter
783
 * to enable reusing that logic. It shouldn't be needed elsewhere.
784
 */
785
struct DefaultFormatter
786
{
787
    template<typename Stream, typename T>
788
35.0M
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<SizeComputer&, TransactionSerParams>, CTxIn>(ParamsStream<SizeComputer&, TransactionSerParams>&, CTxIn const&)
Line
Count
Source
788
4.46M
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<SizeComputer&, TransactionSerParams>, CTxOut>(ParamsStream<SizeComputer&, TransactionSerParams>&, CTxOut const&)
Line
Count
Source
788
7.16M
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<SizeComputer&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
788
4.52M
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<SizeComputer&, TransactionSerParams>, std::shared_ptr<CTransaction const>>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::shared_ptr<CTransaction const> const&)
Line
Count
Source
788
1.13M
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<SizeComputer, std::vector<unsigned char, std::allocator<unsigned char>>>(SizeComputer&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
788
1.33M
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<DataStream, PrefilledTransaction>(DataStream&, PrefilledTransaction const&)
Line
Count
Source
788
11
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<DataStream&, TransactionSerParams>, std::shared_ptr<CTransaction const>>(ParamsStream<DataStream&, TransactionSerParams>&, std::shared_ptr<CTransaction const> const&)
Line
Count
Source
788
85
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<DataStream&, TransactionSerParams>, CTxIn>(ParamsStream<DataStream&, TransactionSerParams>&, CTxIn const&)
Line
Count
Source
788
125k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<DataStream&, TransactionSerParams>, CTxOut>(ParamsStream<DataStream&, TransactionSerParams>&, CTxOut const&)
Line
Count
Source
788
267k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<DataStream&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
788
288k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<DataStream, uint256>(DataStream&, uint256 const&)
Line
Count
Source
788
273k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<VectorWriter&, TransactionSerParams>, CTxIn>(ParamsStream<VectorWriter&, TransactionSerParams>&, CTxIn const&)
Line
Count
Source
788
69.5k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<VectorWriter&, TransactionSerParams>, CTxOut>(ParamsStream<VectorWriter&, TransactionSerParams>&, CTxOut const&)
Line
Count
Source
788
170k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<VectorWriter&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
788
84.3k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<HashWriter&, TransactionSerParams>, CTxIn>(ParamsStream<HashWriter&, TransactionSerParams>&, CTxIn const&)
Line
Count
Source
788
2.10M
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<HashWriter&, TransactionSerParams>, CTxOut>(ParamsStream<HashWriter&, TransactionSerParams>&, CTxOut const&)
Line
Count
Source
788
3.83M
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<HashWriter&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>>(ParamsStream<HashWriter&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
788
3.10M
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<DataStream&, CAddress::SerParams>, CAddress>(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress const&)
Line
Count
Source
788
6
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<DataStream, int>(DataStream&, int const&)
Line
Count
Source
788
4.07M
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<DataStream&, serialize_tests::BaseFormat>, serialize_tests::Base>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, serialize_tests::Base const&)
Line
Count
Source
788
4
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
788
575
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
Unexecuted instantiation: void DefaultFormatter::Ser<DataStream, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
void DefaultFormatter::Ser<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, CAddress>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CAddress const&)
Line
Count
Source
788
6
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<SizeComputer, PrefilledTransaction>(SizeComputer&, PrefilledTransaction const&)
Line
Count
Source
788
35.7k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<VectorWriter, PrefilledTransaction>(VectorWriter&, PrefilledTransaction const&)
Line
Count
Source
788
18.8k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<VectorWriter&, TransactionSerParams>, std::shared_ptr<CTransaction const>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::shared_ptr<CTransaction const> const&)
Line
Count
Source
788
45.3k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<VectorWriter, CInv>(VectorWriter&, CInv const&)
Line
Count
Source
788
84.8k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<VectorWriter, uint256>(VectorWriter&, uint256 const&)
Line
Count
Source
788
43.4k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
Unexecuted instantiation: void DefaultFormatter::Ser<VectorWriter, CBlockHeader>(VectorWriter&, CBlockHeader const&)
void DefaultFormatter::Ser<ParamsStream<VectorWriter&, TransactionSerParams>, CBlock>(ParamsStream<VectorWriter&, TransactionSerParams>&, CBlock const&)
Line
Count
Source
788
26.8k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<VectorWriter&, CAddress::SerParams>, CAddress>(ParamsStream<VectorWriter&, CAddress::SerParams>&, CAddress const&)
Line
Count
Source
788
18.9k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<SizeComputer, CTxUndo>(SizeComputer&, CTxUndo const&)
Line
Count
Source
788
45.0k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<HashWriter, CTxUndo>(HashWriter&, CTxUndo const&)
Line
Count
Source
788
45.0k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<BufferedWriter<AutoFile>, CTxUndo>(BufferedWriter<AutoFile>&, CTxUndo const&)
Line
Count
Source
788
45.0k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, std::shared_ptr<CTransaction const>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::shared_ptr<CTransaction const> const&)
Line
Count
Source
788
153k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CTxIn>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, CTxIn const&)
Line
Count
Source
788
185k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CTxOut>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, CTxOut const&)
Line
Count
Source
788
381k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
788
921k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<AutoFile&, TransactionSerParams>, CTxIn>(ParamsStream<AutoFile&, TransactionSerParams>&, CTxIn const&)
Line
Count
Source
788
2.38k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<AutoFile&, TransactionSerParams>, CTxOut>(ParamsStream<AutoFile&, TransactionSerParams>&, CTxOut const&)
Line
Count
Source
788
1.87k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<ParamsStream<AutoFile&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
788
4.51k
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
void DefaultFormatter::Ser<DataStream, CCoin>(DataStream&, CCoin const&)
Line
Count
Source
788
2
    static void Ser(Stream& s, const T& t) { Serialize(s, t); }
Unexecuted instantiation: void DefaultFormatter::Ser<DataStream, unsigned int>(DataStream&, unsigned int const&)
789
790
    template<typename Stream, typename T>
791
3.94M
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<SpanReader, std::vector<unsigned char, std::allocator<unsigned char>>>(SpanReader&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
791
292
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<DataStream, PrefilledTransaction>(DataStream&, PrefilledTransaction&)
Line
Count
Source
791
21.6k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<DataStream&, TransactionSerParams>, std::shared_ptr<CTransaction const>>(ParamsStream<DataStream&, TransactionSerParams>&, std::shared_ptr<CTransaction const>&)
Line
Count
Source
791
79.2k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<DataStream&, TransactionSerParams>, CTxIn>(ParamsStream<DataStream&, TransactionSerParams>&, CTxIn&)
Line
Count
Source
791
137k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<DataStream&, TransactionSerParams>, CTxOut>(ParamsStream<DataStream&, TransactionSerParams>&, CTxOut&)
Line
Count
Source
791
289k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<DataStream&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
791
184k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<DataStream, CTxIn>(DataStream&, CTxIn&)
Line
Count
Source
791
4.79k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<DataStream, CTxOut>(DataStream&, CTxOut&)
Line
Count
Source
791
4.78k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
791
9.12k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<SpanReader, CTxIn>(SpanReader&, CTxIn&)
Line
Count
Source
791
1
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<SpanReader, CTxOut>(SpanReader&, CTxOut&)
Line
Count
Source
791
2
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<SpanReader&, CAddress::SerParams>, CAddress>(ParamsStream<SpanReader&, CAddress::SerParams>&, CAddress&)
Line
Count
Source
791
7
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<DataStream, uint256>(DataStream&, uint256&)
Line
Count
Source
791
78.9k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<SpanReader&, TransactionSerParams>, CTxIn>(ParamsStream<SpanReader&, TransactionSerParams>&, CTxIn&)
Line
Count
Source
791
332k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<SpanReader&, TransactionSerParams>, CTxOut>(ParamsStream<SpanReader&, TransactionSerParams>&, CTxOut&)
Line
Count
Source
791
521k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<SpanReader&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>>(ParamsStream<SpanReader&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
791
1.87M
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<DataStream, int>(DataStream&, int&)
Line
Count
Source
791
39
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<DataStream&, serialize_tests::BaseFormat>, serialize_tests::Base>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, serialize_tests::Base&)
Line
Count
Source
791
4
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<SpanReader, uint256>(SpanReader&, uint256&)
Line
Count
Source
791
1.78k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
Unexecuted instantiation: void DefaultFormatter::Unser<DataStream, wallet::CMerkleTx>(DataStream&, wallet::CMerkleTx&)
Unexecuted instantiation: void DefaultFormatter::Unser<DataStream, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&)
void DefaultFormatter::Unser<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, CAddress>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CAddress&)
Line
Count
Source
791
8
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<AutoFile&, TransactionSerParams>, CTxIn>(ParamsStream<AutoFile&, TransactionSerParams>&, CTxIn&)
Line
Count
Source
791
517
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<AutoFile&, TransactionSerParams>, CTxOut>(ParamsStream<AutoFile&, TransactionSerParams>&, CTxOut&)
Line
Count
Source
791
832
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<AutoFile&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
791
860
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<DataStream, unsigned char>(DataStream&, unsigned char&)
Line
Count
Source
791
1.03k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<DataStream&, CAddress::SerParams>, CAddress>(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress&)
Line
Count
Source
791
6.90k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<DataStream, CInv>(DataStream&, CInv&)
Line
Count
Source
791
167k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<HashVerifier<BufferedReader<AutoFile>>, CTxUndo>(HashVerifier<BufferedReader<AutoFile>>&, CTxUndo&)
Line
Count
Source
791
21.0k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<SpanReader&, TransactionSerParams>, std::shared_ptr<CTransaction const>>(ParamsStream<SpanReader&, TransactionSerParams>&, std::shared_ptr<CTransaction const>&)
Line
Count
Source
791
192k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<DataStream, COutPoint>(DataStream&, COutPoint&)
Line
Count
Source
791
2
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<BufferedFile&, TransactionSerParams>, std::shared_ptr<CTransaction const>>(ParamsStream<BufferedFile&, TransactionSerParams>&, std::shared_ptr<CTransaction const>&)
Line
Count
Source
791
2.01k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<BufferedFile&, TransactionSerParams>, CTxIn>(ParamsStream<BufferedFile&, TransactionSerParams>&, CTxIn&)
Line
Count
Source
791
2.01k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<BufferedFile&, TransactionSerParams>, CTxOut>(ParamsStream<BufferedFile&, TransactionSerParams>&, CTxOut&)
Line
Count
Source
791
3.96k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<ParamsStream<BufferedFile&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>>(ParamsStream<BufferedFile&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
791
2.05k
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
void DefaultFormatter::Unser<DataStream, unsigned int>(DataStream&, unsigned int&)
Line
Count
Source
791
549
    static void Unser(Stream& s, T& t) { Unserialize(s, t); }
792
};
793
794
/**
795
 * Limited vector formatter. Throws an error if a vector is oversized.
796
 */
797
798
template<size_t Limit, class Formatter = DefaultFormatter>
799
struct LimitedVectorFormatter
800
{
801
    template<typename Stream, typename V>
802
    void Unser(Stream& s, V& v)
803
58
    {
804
58
        Formatter formatter;
805
58
        v.clear();
806
58
        size_t size = ReadCompactSize(s);
807
58
        if (size > Limit) {
808
5
            throw std::ios_base::failure("Vector length limit exceeded");
809
5
        }
810
53
        v.reserve(size);
811
1.12k
        for (size_t i = 0; i < size; ++i) {
812
1.06k
            v.emplace_back();
813
1.06k
            formatter.Unser(s, v.back());
814
1.06k
        }
815
53
    }
void LimitedVectorFormatter<0ul, DefaultFormatter>::Unser<DataStream, std::vector<int, std::allocator<int>>>(DataStream&, std::vector<int, std::allocator<int>>&)
Line
Count
Source
803
1
    {
804
1
        Formatter formatter;
805
1
        v.clear();
806
1
        size_t size = ReadCompactSize(s);
807
1
        if (size > Limit) {
808
1
            throw std::ios_base::failure("Vector length limit exceeded");
809
1
        }
810
0
        v.reserve(size);
811
0
        for (size_t i = 0; i < size; ++i) {
812
0
            v.emplace_back();
813
0
            formatter.Unser(s, v.back());
814
0
        }
815
0
    }
void LimitedVectorFormatter<10ul, DefaultFormatter>::Unser<DataStream, std::vector<int, std::allocator<int>>>(DataStream&, std::vector<int, std::allocator<int>>&)
Line
Count
Source
803
1
    {
804
1
        Formatter formatter;
805
1
        v.clear();
806
1
        size_t size = ReadCompactSize(s);
807
1
        if (size > Limit) {
808
1
            throw std::ios_base::failure("Vector length limit exceeded");
809
1
        }
810
0
        v.reserve(size);
811
0
        for (size_t i = 0; i < size; ++i) {
812
0
            v.emplace_back();
813
0
            formatter.Unser(s, v.back());
814
0
        }
815
0
    }
void LimitedVectorFormatter<12ul, DefaultFormatter>::Unser<DataStream, std::vector<int, std::allocator<int>>>(DataStream&, std::vector<int, std::allocator<int>>&)
Line
Count
Source
803
1
    {
804
1
        Formatter formatter;
805
1
        v.clear();
806
1
        size_t size = ReadCompactSize(s);
807
1
        if (size > Limit) {
808
1
            throw std::ios_base::failure("Vector length limit exceeded");
809
1
        }
810
0
        v.reserve(size);
811
0
        for (size_t i = 0; i < size; ++i) {
812
0
            v.emplace_back();
813
0
            formatter.Unser(s, v.back());
814
0
        }
815
0
    }
void LimitedVectorFormatter<13ul, DefaultFormatter>::Unser<DataStream, std::vector<int, std::allocator<int>>>(DataStream&, std::vector<int, std::allocator<int>>&)
Line
Count
Source
803
1
    {
804
1
        Formatter formatter;
805
1
        v.clear();
806
1
        size_t size = ReadCompactSize(s);
807
1
        if (size > Limit) {
808
0
            throw std::ios_base::failure("Vector length limit exceeded");
809
0
        }
810
1
        v.reserve(size);
811
14
        for (size_t i = 0; i < size; ++i) {
812
13
            v.emplace_back();
813
13
            formatter.Unser(s, v.back());
814
13
        }
815
1
    }
void LimitedVectorFormatter<14ul, DefaultFormatter>::Unser<DataStream, std::vector<int, std::allocator<int>>>(DataStream&, std::vector<int, std::allocator<int>>&)
Line
Count
Source
803
1
    {
804
1
        Formatter formatter;
805
1
        v.clear();
806
1
        size_t size = ReadCompactSize(s);
807
1
        if (size > Limit) {
808
0
            throw std::ios_base::failure("Vector length limit exceeded");
809
0
        }
810
1
        v.reserve(size);
811
14
        for (size_t i = 0; i < size; ++i) {
812
13
            v.emplace_back();
813
13
            formatter.Unser(s, v.back());
814
13
        }
815
1
    }
void LimitedVectorFormatter<100ul, DefaultFormatter>::Unser<DataStream, std::vector<int, std::allocator<int>>>(DataStream&, std::vector<int, std::allocator<int>>&)
Line
Count
Source
803
1
    {
804
1
        Formatter formatter;
805
1
        v.clear();
806
1
        size_t size = ReadCompactSize(s);
807
1
        if (size > Limit) {
808
0
            throw std::ios_base::failure("Vector length limit exceeded");
809
0
        }
810
1
        v.reserve(size);
811
14
        for (size_t i = 0; i < size; ++i) {
812
13
            v.emplace_back();
813
13
            formatter.Unser(s, v.back());
814
13
        }
815
1
    }
void LimitedVectorFormatter<512ul, DefaultFormatter>::Unser<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
803
52
    {
804
52
        Formatter formatter;
805
52
        v.clear();
806
52
        size_t size = ReadCompactSize(s);
807
52
        if (size > Limit) {
808
2
            throw std::ios_base::failure("Vector length limit exceeded");
809
2
        }
810
50
        v.reserve(size);
811
1.08k
        for (size_t i = 0; i < size; ++i) {
812
1.03k
            v.emplace_back();
813
1.03k
            formatter.Unser(s, v.back());
814
1.03k
        }
815
50
    }
816
817
    template<typename Stream, typename V>
818
    void Ser(Stream& s, const V& v)
819
    {
820
        VectorFormatter<Formatter>{}.Ser(s, v);
821
    }
822
};
823
824
825
826
827
/**
828
 * string
829
 */
830
template<typename Stream, typename C>
831
void Serialize(Stream& os, const std::basic_string<C>& str)
832
720k
{
833
720k
    WriteCompactSize(os, str.size());
834
720k
    if (!str.empty())
835
667k
        os.write(MakeByteSpan(str));
836
720k
}
void Serialize<DataStream, char>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
832
718k
{
833
718k
    WriteCompactSize(os, str.size());
834
718k
    if (!str.empty())
835
665k
        os.write(MakeByteSpan(str));
836
718k
}
void Serialize<SizeComputer, char>(SizeComputer&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
832
1
{
833
1
    WriteCompactSize(os, str.size());
834
1
    if (!str.empty())
835
1
        os.write(MakeByteSpan(str));
836
1
}
void Serialize<AutoFile, char>(AutoFile&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
832
3
{
833
3
    WriteCompactSize(os, str.size());
834
3
    if (!str.empty())
835
2
        os.write(MakeByteSpan(str));
836
3
}
void Serialize<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>, char>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
832
2
{
833
2
    WriteCompactSize(os, str.size());
834
2
    if (!str.empty())
835
2
        os.write(MakeByteSpan(str));
836
2
}
void Serialize<HashedSourceWriter<DataStream>, char>(HashedSourceWriter<DataStream>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
832
1
{
833
1
    WriteCompactSize(os, str.size());
834
1
    if (!str.empty())
835
1
        os.write(MakeByteSpan(str));
836
1
}
void Serialize<VectorWriter, char>(VectorWriter&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
832
1.74k
{
833
1.74k
    WriteCompactSize(os, str.size());
834
1.74k
    if (!str.empty())
835
1.73k
        os.write(MakeByteSpan(str));
836
1.74k
}
void Serialize<HashWriter, char>(HashWriter&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
832
52
{
833
52
    WriteCompactSize(os, str.size());
834
52
    if (!str.empty())
835
52
        os.write(MakeByteSpan(str));
836
52
}
837
838
template<typename Stream, typename C>
839
void Unserialize(Stream& is, std::basic_string<C>& str)
840
117k
{
841
117k
    unsigned int nSize = ReadCompactSize(is);
842
117k
    str.resize(nSize);
843
117k
    if (nSize != 0)
844
103k
        is.read(MakeWritableByteSpan(str));
845
117k
}
void Unserialize<DataStream, char>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
840
117k
{
841
117k
    unsigned int nSize = ReadCompactSize(is);
842
117k
    str.resize(nSize);
843
117k
    if (nSize != 0)
844
103k
        is.read(MakeWritableByteSpan(str));
845
117k
}
Unexecuted instantiation: void Unserialize<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>, char>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Unserialize<HashVerifier<DataStream>, char>(HashVerifier<DataStream>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
840
1
{
841
1
    unsigned int nSize = ReadCompactSize(is);
842
1
    str.resize(nSize);
843
1
    if (nSize != 0)
844
1
        is.read(MakeWritableByteSpan(str));
845
1
}
void Unserialize<SpanReader, char>(SpanReader&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
840
10
{
841
10
    unsigned int nSize = ReadCompactSize(is);
842
10
    str.resize(nSize);
843
10
    if (nSize != 0)
844
10
        is.read(MakeWritableByteSpan(str));
845
10
}
846
847
/**
848
 * string_view
849
 */
850
template<typename Stream, typename C>
851
void Serialize(Stream& os, const std::basic_string_view<C>& str)
852
1
{
853
1
    WriteCompactSize(os, str.size());
854
1
    if (!str.empty()) {
855
1
        os.write(MakeByteSpan(str));
856
1
    }
857
1
}
858
859
/**
860
 * prevector
861
 */
862
template <typename Stream, unsigned int N, typename T>
863
void Serialize(Stream& os, const prevector<N, T>& v)
864
35.0M
{
865
35.0M
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
34.7M
        WriteCompactSize(os, v.size());
867
34.7M
        if (!v.empty()) os.write(MakeByteSpan(v));
868
34.7M
    } else {
869
265k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
265k
    }
871
35.0M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, 36u, unsigned char>(ParamsStream<SizeComputer&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
11.6M
{
865
11.6M
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
11.6M
        WriteCompactSize(os, v.size());
867
11.6M
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
11.6M
}
void Serialize<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, 16u, unsigned char>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, prevector<16u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
18
{
865
18
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
18
        WriteCompactSize(os, v.size());
867
18
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
18
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, 16u, unsigned char>(ParamsStream<DataStream&, CAddress::SerParams>&, prevector<16u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
19
{
865
19
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
19
        WriteCompactSize(os, v.size());
867
19
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
19
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, 36u, unsigned char>(ParamsStream<DataStream&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
393k
{
865
393k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
393k
        WriteCompactSize(os, v.size());
867
393k
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
393k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, 36u, unsigned char>(ParamsStream<VectorWriter&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
240k
{
865
240k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
240k
        WriteCompactSize(os, v.size());
867
240k
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
240k
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, 36u, unsigned char>(ParamsStream<HashWriter&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
5.94M
{
865
5.94M
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
5.94M
        WriteCompactSize(os, v.size());
867
5.94M
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
5.94M
}
Unexecuted instantiation: void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, 16u, unsigned char>(ParamsStream<VectorWriter&, CAddress::SerParams>&, prevector<16u, unsigned char, unsigned int, int> const&)
void Serialize<DataStream, 8u, int>(DataStream&, prevector<8u, int, unsigned int, int> const&)
Line
Count
Source
864
265k
{
865
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
        WriteCompactSize(os, v.size());
867
        if (!v.empty()) os.write(MakeByteSpan(v));
868
265k
    } else {
869
265k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
265k
    }
871
265k
}
void Serialize<SizeComputer, 36u, unsigned char>(SizeComputer&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
402k
{
865
402k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
402k
        WriteCompactSize(os, v.size());
867
402k
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
402k
}
void Serialize<DataStream, 36u, unsigned char>(DataStream&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
10.0k
{
865
10.0k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
10.0k
        WriteCompactSize(os, v.size());
867
10.0k
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
10.0k
}
Unexecuted instantiation: void Serialize<ParamsStream<VectorWriter&, CNetAddr::SerParams>, 16u, unsigned char>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, prevector<16u, unsigned char, unsigned int, int> const&)
void Serialize<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, 16u, unsigned char>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, prevector<16u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
50.3k
{
865
50.3k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
50.3k
        WriteCompactSize(os, v.size());
867
50.3k
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
50.3k
}
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, 16u, unsigned char>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, prevector<16u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
50.3k
{
865
50.3k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
50.3k
        WriteCompactSize(os, v.size());
867
50.3k
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
50.3k
}
void Serialize<HashWriter, 36u, unsigned char>(HashWriter&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
15.4M
{
865
15.4M
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
15.4M
        WriteCompactSize(os, v.size());
867
15.4M
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
15.4M
}
void Serialize<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>, 16u, unsigned char>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, prevector<16u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
33
{
865
33
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
33
        WriteCompactSize(os, v.size());
867
33
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
33
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, 36u, unsigned char>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
567k
{
865
567k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
567k
        WriteCompactSize(os, v.size());
867
567k
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
567k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, 36u, unsigned char>(ParamsStream<AutoFile&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
864
4.25k
{
865
4.25k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
866
4.25k
        WriteCompactSize(os, v.size());
867
4.25k
        if (!v.empty()) os.write(MakeByteSpan(v));
868
    } else {
869
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
870
    }
871
4.25k
}
872
873
874
template <typename Stream, unsigned int N, typename T>
875
void Unserialize(Stream& is, prevector<N, T>& v)
876
1.30M
{
877
1.30M
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
878
        // Limit size per read so bogus size value won't cause out of memory
879
1.30M
        v.clear();
880
1.30M
        unsigned int nSize = ReadCompactSize(is);
881
1.30M
        unsigned int i = 0;
882
2.37M
        while (i < nSize) {
883
1.07M
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
884
1.07M
            v.resize_uninitialized(i + blk);
885
1.07M
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
886
1.07M
            i += blk;
887
1.07M
        }
888
    } else {
889
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
890
    }
891
1.30M
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, 36u, unsigned char>(ParamsStream<DataStream&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
876
426k
{
877
426k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
878
        // Limit size per read so bogus size value won't cause out of memory
879
426k
        v.clear();
880
426k
        unsigned int nSize = ReadCompactSize(is);
881
426k
        unsigned int i = 0;
882
802k
        while (i < nSize) {
883
375k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
884
375k
            v.resize_uninitialized(i + blk);
885
375k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
886
375k
            i += blk;
887
375k
        }
888
    } else {
889
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
890
    }
891
426k
}
void Unserialize<DataStream, 36u, unsigned char>(DataStream&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
876
9.76k
{
877
9.76k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
878
        // Limit size per read so bogus size value won't cause out of memory
879
9.76k
        v.clear();
880
9.76k
        unsigned int nSize = ReadCompactSize(is);
881
9.76k
        unsigned int i = 0;
882
14.7k
        while (i < nSize) {
883
5.00k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
884
5.00k
            v.resize_uninitialized(i + blk);
885
5.00k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
886
5.00k
            i += blk;
887
5.00k
        }
888
    } else {
889
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
890
    }
891
9.76k
}
void Unserialize<SpanReader, 36u, unsigned char>(SpanReader&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
876
8.14k
{
877
8.14k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
878
        // Limit size per read so bogus size value won't cause out of memory
879
8.14k
        v.clear();
880
8.14k
        unsigned int nSize = ReadCompactSize(is);
881
8.14k
        unsigned int i = 0;
882
16.2k
        while (i < nSize) {
883
8.13k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
884
8.13k
            v.resize_uninitialized(i + blk);
885
8.13k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
886
8.13k
            i += blk;
887
8.13k
        }
888
    } else {
889
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
890
    }
891
8.14k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, 36u, unsigned char>(ParamsStream<SpanReader&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
876
853k
{
877
853k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
878
        // Limit size per read so bogus size value won't cause out of memory
879
853k
        v.clear();
880
853k
        unsigned int nSize = ReadCompactSize(is);
881
853k
        unsigned int i = 0;
882
1.52M
        while (i < nSize) {
883
675k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
884
675k
            v.resize_uninitialized(i + blk);
885
675k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
886
675k
            i += blk;
887
675k
        }
888
    } else {
889
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
890
    }
891
853k
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, 36u, unsigned char>(ParamsStream<AutoFile&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
876
1.34k
{
877
1.34k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
878
        // Limit size per read so bogus size value won't cause out of memory
879
1.34k
        v.clear();
880
1.34k
        unsigned int nSize = ReadCompactSize(is);
881
1.34k
        unsigned int i = 0;
882
2.32k
        while (i < nSize) {
883
979
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
884
979
            v.resize_uninitialized(i + blk);
885
979
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
886
979
            i += blk;
887
979
        }
888
    } else {
889
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
890
    }
891
1.34k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, 36u, unsigned char>(ParamsStream<BufferedFile&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
876
5.97k
{
877
5.97k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
878
        // Limit size per read so bogus size value won't cause out of memory
879
5.97k
        v.clear();
880
5.97k
        unsigned int nSize = ReadCompactSize(is);
881
5.97k
        unsigned int i = 0;
882
11.8k
        while (i < nSize) {
883
5.89k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
884
5.89k
            v.resize_uninitialized(i + blk);
885
5.89k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
886
5.89k
            i += blk;
887
5.89k
        }
888
    } else {
889
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
890
    }
891
5.97k
}
892
893
894
/**
895
 * vector
896
 */
897
template <typename Stream, typename T, typename A>
898
void Serialize(Stream& os, const std::vector<T, A>& v)
899
28.4M
{
900
28.4M
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
10.6M
        WriteCompactSize(os, v.size());
902
10.6M
        if (!v.empty()) os.write(MakeByteSpan(v));
903
10.6M
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
1
        WriteCompactSize(os, v.size());
908
27
        for (bool elem : v) {
909
27
            ::Serialize(os, elem);
910
27
        }
911
17.7M
    } else {
912
17.7M
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
17.7M
    }
914
28.4M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, CTxIn, std::allocator<CTxIn>>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
899
4.44M
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
4.44M
    } else {
912
4.44M
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
4.44M
    }
914
4.44M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, CTxOut, std::allocator<CTxOut>>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
899
3.71M
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
3.71M
    } else {
912
3.71M
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
3.71M
    }
914
3.71M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
899
954k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
954k
    } else {
912
954k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
954k
    }
914
954k
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, unsigned char, std::allocator<unsigned char>>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
899
4.52M
{
900
4.52M
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
4.52M
        WriteCompactSize(os, v.size());
902
4.52M
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
4.52M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
899
710k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
710k
    } else {
912
710k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
710k
    }
914
710k
}
void Serialize<SizeComputer, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(SizeComputer&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
899
116k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
116k
    } else {
912
116k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
116k
    }
914
116k
}
void Serialize<SizeComputer, unsigned char, std::allocator<unsigned char>>(SizeComputer&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
899
1.34M
{
900
1.34M
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
1.34M
        WriteCompactSize(os, v.size());
902
1.34M
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
1.34M
}
void Serialize<DataStream, PrefilledTransaction, std::allocator<PrefilledTransaction>>(DataStream&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
899
9
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
9
    } else {
912
9
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
9
    }
914
9
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, CTxIn, std::allocator<CTxIn>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
899
196k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
196k
    } else {
912
196k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
196k
    }
914
196k
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, CTxOut, std::allocator<CTxOut>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
899
101k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
101k
    } else {
912
101k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
101k
    }
914
101k
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
899
116k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
116k
    } else {
912
116k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
116k
    }
914
116k
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, unsigned char, std::allocator<unsigned char>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
899
288k
{
900
288k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
288k
        WriteCompactSize(os, v.size());
902
288k
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
288k
}
void Serialize<DataStream, unsigned char, std::allocator<unsigned char>>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
899
96.1k
{
900
96.1k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
96.1k
        WriteCompactSize(os, v.size());
902
96.1k
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
96.1k
}
void Serialize<DataStream, uint256, std::allocator<uint256>>(DataStream&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
899
29.9k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
29.9k
    } else {
912
29.9k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
29.9k
    }
914
29.9k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, CTxIn, std::allocator<CTxIn>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
899
92.2k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
92.2k
    } else {
912
92.2k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
92.2k
    }
914
92.2k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, CTxOut, std::allocator<CTxOut>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
899
59.3k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
59.3k
    } else {
912
59.3k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
59.3k
    }
914
59.3k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
899
42.0k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
42.0k
    } else {
912
42.0k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
42.0k
    }
914
42.0k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, unsigned char, std::allocator<unsigned char>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
899
84.3k
{
900
84.3k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
84.3k
        WriteCompactSize(os, v.size());
902
84.3k
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
84.3k
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, CTxIn, std::allocator<CTxIn>>(ParamsStream<HashWriter&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
899
2.81M
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
2.81M
    } else {
912
2.81M
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
2.81M
    }
914
2.81M
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, CTxOut, std::allocator<CTxOut>>(ParamsStream<HashWriter&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
899
2.41M
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
2.41M
    } else {
912
2.41M
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
2.41M
    }
914
2.41M
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(ParamsStream<HashWriter&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
899
556k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
556k
    } else {
912
556k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
556k
    }
914
556k
}
void Serialize<ParamsStream<HashWriter&, TransactionSerParams>, unsigned char, std::allocator<unsigned char>>(ParamsStream<HashWriter&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
899
3.10M
{
900
3.10M
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
3.10M
        WriteCompactSize(os, v.size());
902
3.10M
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
3.10M
}
void Serialize<ParamsStream<DataStream&, CAddress::SerParams>, CAddress, std::allocator<CAddress>>(ParamsStream<DataStream&, CAddress::SerParams>&, std::vector<CAddress, std::allocator<CAddress>> const&)
Line
Count
Source
899
2
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
2
    } else {
912
2
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
2
    }
914
2
}
void Serialize<DataStream, int, std::allocator<int>>(DataStream&, std::vector<int, std::allocator<int>> const&)
Line
Count
Source
899
265k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
265k
    } else {
912
265k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
265k
    }
914
265k
}
void Serialize<HashWriter, unsigned char, std::allocator<unsigned char>>(HashWriter&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
899
270k
{
900
270k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
270k
        WriteCompactSize(os, v.size());
902
270k
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
270k
}
void Serialize<HashWriter, bool, std::allocator<bool>>(HashWriter&, std::vector<bool, std::allocator<bool>> const&)
Line
Count
Source
899
1
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
1
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
1
        WriteCompactSize(os, v.size());
908
27
        for (bool elem : v) {
909
27
            ::Serialize(os, elem);
910
27
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
1
}
void Serialize<ParamsStream<DataStream&, serialize_tests::BaseFormat>, serialize_tests::Base, std::allocator<serialize_tests::Base>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>> const&)
Line
Count
Source
899
2
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
2
    } else {
912
2
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
2
    }
914
2
}
void Serialize<DataStream, std::byte, std::allocator<std::byte>>(DataStream&, std::vector<std::byte, std::allocator<std::byte>> const&)
Line
Count
Source
899
565
{
900
565
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
565
        WriteCompactSize(os, v.size());
902
565
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
565
}
void Serialize<AutoFile, unsigned char, std::allocator<unsigned char>>(AutoFile&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
899
8.00k
{
900
8.00k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
8.00k
        WriteCompactSize(os, v.size());
902
8.00k
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
8.00k
}
void Serialize<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(DataStream&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
899
270
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
270
    } else {
912
270
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
270
    }
914
270
}
void Serialize<VectorWriter, unsigned char, std::allocator<unsigned char>>(VectorWriter&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
899
863
{
900
863
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
863
        WriteCompactSize(os, v.size());
902
863
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
863
}
void Serialize<DataStream, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(DataStream&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
Line
Count
Source
899
24.7k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
24.7k
    } else {
912
24.7k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
24.7k
    }
914
24.7k
}
void Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, CAddress, std::allocator<CAddress>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, std::vector<CAddress, std::allocator<CAddress>> const&)
Line
Count
Source
899
39
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
39
    } else {
912
39
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
39
    }
914
39
}
void Serialize<SizeComputer, PrefilledTransaction, std::allocator<PrefilledTransaction>>(SizeComputer&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
899
35.6k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
35.6k
    } else {
912
35.6k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
35.6k
    }
914
35.6k
}
void Serialize<VectorWriter, PrefilledTransaction, std::allocator<PrefilledTransaction>>(VectorWriter&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
899
18.8k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
18.8k
    } else {
912
18.8k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
18.8k
    }
914
18.8k
}
void Serialize<VectorWriter, CInv, std::allocator<CInv>>(VectorWriter&, std::vector<CInv, std::allocator<CInv>> const&)
Line
Count
Source
899
58.7k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
58.7k
    } else {
912
58.7k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
58.7k
    }
914
58.7k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
899
35.0k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
35.0k
    } else {
912
35.0k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
35.0k
    }
914
35.0k
}
void Serialize<VectorWriter, uint256, std::allocator<uint256>>(VectorWriter&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
899
3.01k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
3.01k
    } else {
912
3.01k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
3.01k
    }
914
3.01k
}
void Serialize<VectorWriter, CBlockHeader, std::allocator<CBlockHeader>>(VectorWriter&, std::vector<CBlockHeader, std::allocator<CBlockHeader>> const&)
Line
Count
Source
899
9
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
9
    } else {
912
9
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
9
    }
914
9
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, CBlock, std::allocator<CBlock>>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::vector<CBlock, std::allocator<CBlock>> const&)
Line
Count
Source
899
5.27k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
5.27k
    } else {
912
5.27k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
5.27k
    }
914
5.27k
}
void Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>, CAddress, std::allocator<CAddress>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, std::vector<CAddress, std::allocator<CAddress>> const&)
Line
Count
Source
899
134
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
134
    } else {
912
134
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
134
    }
914
134
}
void Serialize<SizeComputer, CTxUndo, std::allocator<CTxUndo>>(SizeComputer&, std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
899
100k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
100k
    } else {
912
100k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
100k
    }
914
100k
}
void Serialize<HashWriter, CTxUndo, std::allocator<CTxUndo>>(HashWriter&, std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
899
100k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
100k
    } else {
912
100k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
100k
    }
914
100k
}
void Serialize<BufferedWriter<AutoFile>, CTxUndo, std::allocator<CTxUndo>>(BufferedWriter<AutoFile>&, std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
899
100k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
100k
    } else {
912
100k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
100k
    }
914
100k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
899
102k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
102k
    } else {
912
102k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
102k
    }
914
102k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CTxIn, std::allocator<CTxIn>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
899
270k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
270k
    } else {
912
270k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
270k
    }
914
270k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CTxOut, std::allocator<CTxOut>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
899
153k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
153k
    } else {
912
153k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
153k
    }
914
153k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
899
141k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
141k
    } else {
912
141k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
141k
    }
914
141k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, unsigned char, std::allocator<unsigned char>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
899
921k
{
900
921k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
921k
        WriteCompactSize(os, v.size());
902
921k
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
921k
}
void Serialize<AutoFile, std::byte, std::allocator<std::byte>>(AutoFile&, std::vector<std::byte, std::allocator<std::byte>> const&)
Line
Count
Source
899
1.02k
{
900
1.02k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
1.02k
        WriteCompactSize(os, v.size());
902
1.02k
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
1.02k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, CTxIn, std::allocator<CTxIn>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
899
2.35k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
2.35k
    } else {
912
2.35k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
2.35k
    }
914
2.35k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, CTxOut, std::allocator<CTxOut>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
899
1.21k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
1.21k
    } else {
912
1.21k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
1.21k
    }
914
1.21k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
899
2.26k
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
2.26k
    } else {
912
2.26k
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
2.26k
    }
914
2.26k
}
void Serialize<ParamsStream<AutoFile&, TransactionSerParams>, unsigned char, std::allocator<unsigned char>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
899
4.51k
{
900
4.51k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
4.51k
        WriteCompactSize(os, v.size());
902
4.51k
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
4.51k
}
void Serialize<DataStream, CCoin, std::allocator<CCoin>>(DataStream&, std::vector<CCoin, std::allocator<CCoin>> const&)
Line
Count
Source
899
3
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
3
    } else {
912
3
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
3
    }
914
3
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
899
41
{
900
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
        WriteCompactSize(os, v.size());
902
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
41
    } else {
912
41
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
41
    }
914
41
}
Unexecuted instantiation: void Serialize<DataStream, unsigned int, std::allocator<unsigned int>>(DataStream&, std::vector<unsigned int, std::allocator<unsigned int>> const&)
void Serialize<DataStream, unsigned char, secure_allocator<unsigned char>>(DataStream&, std::vector<unsigned char, secure_allocator<unsigned char>> const&)
Line
Count
Source
899
4.79k
{
900
4.79k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
901
4.79k
        WriteCompactSize(os, v.size());
902
4.79k
        if (!v.empty()) os.write(MakeByteSpan(v));
903
    } else if constexpr (std::is_same_v<T, bool>) {
904
        // A special case for std::vector<bool>, as dereferencing
905
        // std::vector<bool>::const_iterator does not result in a const bool&
906
        // due to std::vector's special casing for bool arguments.
907
        WriteCompactSize(os, v.size());
908
        for (bool elem : v) {
909
            ::Serialize(os, elem);
910
        }
911
    } else {
912
        Serialize(os, Using<VectorFormatter<DefaultFormatter>>(v));
913
    }
914
4.79k
}
915
916
917
template <typename Stream, typename T, typename A>
918
void Unserialize(Stream& is, std::vector<T, A>& v)
919
3.85M
{
920
3.85M
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
2.14M
        v.clear();
923
2.14M
        unsigned int nSize = ReadCompactSize(is);
924
2.14M
        unsigned int i = 0;
925
2.84M
        while (i < nSize) {
926
702k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
702k
            v.resize(i + blk);
928
702k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
702k
            i += blk;
930
702k
        }
931
2.14M
    } else {
932
1.71M
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
1.71M
    }
934
3.85M
}
void Unserialize<SpanReader, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(SpanReader&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
919
166
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
166
    } else {
932
166
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
166
    }
934
166
}
void Unserialize<SpanReader, unsigned char, std::allocator<unsigned char>>(SpanReader&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
919
61.3k
{
920
61.3k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
61.3k
        v.clear();
923
61.3k
        unsigned int nSize = ReadCompactSize(is);
924
61.3k
        unsigned int i = 0;
925
115k
        while (i < nSize) {
926
54.0k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
54.0k
            v.resize(i + blk);
928
54.0k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
54.0k
            i += blk;
930
54.0k
        }
931
    } else {
932
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
    }
934
61.3k
}
void Unserialize<DataStream, PrefilledTransaction, std::allocator<PrefilledTransaction>>(DataStream&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&)
Line
Count
Source
919
21.6k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
21.6k
    } else {
932
21.6k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
21.6k
    }
934
21.6k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, CTxIn, std::allocator<CTxIn>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
919
194k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
194k
    } else {
932
194k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
194k
    }
934
194k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, CTxOut, std::allocator<CTxOut>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
919
115k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
115k
    } else {
932
115k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
115k
    }
934
115k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
919
94.2k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
94.2k
    } else {
932
94.2k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
94.2k
    }
934
94.2k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, unsigned char, std::allocator<unsigned char>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
919
184k
{
920
184k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
184k
        v.clear();
923
184k
        unsigned int nSize = ReadCompactSize(is);
924
184k
        unsigned int i = 0;
925
369k
        while (i < nSize) {
926
184k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
184k
            v.resize(i + blk);
928
184k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
184k
            i += blk;
930
184k
        }
931
    } else {
932
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
    }
934
184k
}
void Unserialize<DataStream, unsigned char, std::allocator<unsigned char>>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
919
9.82k
{
920
9.82k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
9.82k
        v.clear();
923
9.82k
        unsigned int nSize = ReadCompactSize(is);
924
9.82k
        unsigned int i = 0;
925
19.6k
        while (i < nSize) {
926
9.79k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
9.79k
            v.resize(i + blk);
928
9.79k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
9.79k
            i += blk;
930
9.79k
        }
931
    } else {
932
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
    }
934
9.82k
}
void Unserialize<DataStream, CTxIn, std::allocator<CTxIn>>(DataStream&, std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
919
264
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
264
    } else {
932
264
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
264
    }
934
264
}
void Unserialize<DataStream, CTxOut, std::allocator<CTxOut>>(DataStream&, std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
919
220
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
220
    } else {
932
220
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
220
    }
934
220
}
void Unserialize<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(DataStream&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
919
4.59k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
4.59k
    } else {
932
4.59k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
4.59k
    }
934
4.59k
}
void Unserialize<SpanReader, CTxIn, std::allocator<CTxIn>>(SpanReader&, std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
919
1
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
1
    } else {
932
1
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
1
    }
934
1
}
void Unserialize<SpanReader, CTxOut, std::allocator<CTxOut>>(SpanReader&, std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
919
1
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
1
    } else {
932
1
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
1
    }
934
1
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>(ParamsStream<DataStream&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
919
34.2k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
34.2k
    } else {
932
34.2k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
34.2k
    }
934
34.2k
}
void Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>, CAddress, std::allocator<CAddress>>(ParamsStream<SpanReader&, CAddress::SerParams>&, std::vector<CAddress, std::allocator<CAddress>>&)
Line
Count
Source
919
3
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
3
    } else {
932
3
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
3
    }
934
3
}
void Unserialize<DataStream, uint256, std::allocator<uint256>>(DataStream&, std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
919
16.8k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
16.8k
    } else {
932
16.8k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
16.8k
    }
934
16.8k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, CTxIn, std::allocator<CTxIn>>(ParamsStream<SpanReader&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
919
449k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
449k
    } else {
932
449k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
449k
    }
934
449k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, CTxOut, std::allocator<CTxOut>>(ParamsStream<SpanReader&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
919
240k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
240k
    } else {
932
240k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
240k
    }
934
240k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(ParamsStream<SpanReader&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
919
294k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
294k
    } else {
932
294k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
294k
    }
934
294k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, unsigned char, std::allocator<unsigned char>>(ParamsStream<SpanReader&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
919
1.87M
{
920
1.87M
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
1.87M
        v.clear();
923
1.87M
        unsigned int nSize = ReadCompactSize(is);
924
1.87M
        unsigned int i = 0;
925
2.32M
        while (i < nSize) {
926
445k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
445k
            v.resize(i + blk);
928
445k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
445k
            i += blk;
930
445k
        }
931
    } else {
932
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
    }
934
1.87M
}
void Unserialize<ParamsStream<DataStream&, serialize_tests::BaseFormat>, serialize_tests::Base, std::allocator<serialize_tests::Base>>(ParamsStream<DataStream&, serialize_tests::BaseFormat>&, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>&)
Line
Count
Source
919
2
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
2
    } else {
932
2
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
2
    }
934
2
}
void Unserialize<DataStream, std::byte, std::allocator<std::byte>>(DataStream&, std::vector<std::byte, std::allocator<std::byte>>&)
Line
Count
Source
919
2
{
920
2
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
2
        v.clear();
923
2
        unsigned int nSize = ReadCompactSize(is);
924
2
        unsigned int i = 0;
925
4
        while (i < nSize) {
926
2
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
2
            v.resize(i + blk);
928
2
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
2
            i += blk;
930
2
        }
931
    } else {
932
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
    }
934
2
}
void Unserialize<AutoFile, std::byte, std::allocator<std::byte>>(AutoFile&, std::vector<std::byte, std::allocator<std::byte>>&)
Line
Count
Source
919
514
{
920
514
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
514
        v.clear();
923
514
        unsigned int nSize = ReadCompactSize(is);
924
514
        unsigned int i = 0;
925
1.02k
        while (i < nSize) {
926
514
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
514
            v.resize(i + blk);
928
514
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
514
            i += blk;
930
514
        }
931
    } else {
932
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
    }
934
514
}
void Unserialize<SpanReader, uint256, std::allocator<uint256>>(SpanReader&, std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
919
130
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
130
    } else {
932
130
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
130
    }
934
130
}
void Unserialize<DataStream, wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>(DataStream&, std::vector<wallet::CMerkleTx, std::allocator<wallet::CMerkleTx>>&)
Line
Count
Source
919
11.4k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
11.4k
    } else {
932
11.4k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
11.4k
    }
934
11.4k
}
void Unserialize<DataStream, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(DataStream&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
Line
Count
Source
919
11.4k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
11.4k
    } else {
932
11.4k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
11.4k
    }
934
11.4k
}
void Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, CAddress, std::allocator<CAddress>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, std::vector<CAddress, std::allocator<CAddress>>&)
Line
Count
Source
919
31
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
31
    } else {
932
31
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
31
    }
934
31
}
void Unserialize<SpanReader, std::byte, std::allocator<std::byte>>(SpanReader&, std::vector<std::byte, std::allocator<std::byte>>&)
Line
Count
Source
919
936
{
920
936
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
936
        v.clear();
923
936
        unsigned int nSize = ReadCompactSize(is);
924
936
        unsigned int i = 0;
925
1.87k
        while (i < nSize) {
926
936
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
936
            v.resize(i + blk);
928
936
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
936
            i += blk;
930
936
        }
931
    } else {
932
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
    }
934
936
}
void Unserialize<AutoFile, unsigned char, std::allocator<unsigned char>>(AutoFile&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
919
1.39k
{
920
1.39k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
1.39k
        v.clear();
923
1.39k
        unsigned int nSize = ReadCompactSize(is);
924
1.39k
        unsigned int i = 0;
925
2.79k
        while (i < nSize) {
926
1.39k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
1.39k
            v.resize(i + blk);
928
1.39k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
1.39k
            i += blk;
930
1.39k
        }
931
    } else {
932
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
    }
934
1.39k
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, CTxIn, std::allocator<CTxIn>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
919
972
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
972
    } else {
932
972
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
972
    }
934
972
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, CTxOut, std::allocator<CTxOut>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
919
500
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
500
    } else {
932
500
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
500
    }
934
500
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
919
489
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
489
    } else {
932
489
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
489
    }
934
489
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, unsigned char, std::allocator<unsigned char>>(ParamsStream<AutoFile&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
919
860
{
920
860
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
860
        v.clear();
923
860
        unsigned int nSize = ReadCompactSize(is);
924
860
        unsigned int i = 0;
925
1.72k
        while (i < nSize) {
926
860
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
860
            v.resize(i + blk);
928
860
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
860
            i += blk;
930
860
        }
931
    } else {
932
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
    }
934
860
}
void Unserialize<ParamsStream<DataStream&, CAddress::SerParams>, CAddress, std::allocator<CAddress>>(ParamsStream<DataStream&, CAddress::SerParams>&, std::vector<CAddress, std::allocator<CAddress>>&)
Line
Count
Source
919
58
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
58
    } else {
932
58
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
58
    }
934
58
}
void Unserialize<DataStream, CInv, std::allocator<CInv>>(DataStream&, std::vector<CInv, std::allocator<CInv>>&)
Line
Count
Source
919
39.1k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
39.1k
    } else {
932
39.1k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
39.1k
    }
934
39.1k
}
void Unserialize<HashVerifier<BufferedReader<AutoFile>>, CTxUndo, std::allocator<CTxUndo>>(HashVerifier<BufferedReader<AutoFile>>&, std::vector<CTxUndo, std::allocator<CTxUndo>>&)
Line
Count
Source
919
33.7k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
33.7k
    } else {
932
33.7k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
33.7k
    }
934
33.7k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>(ParamsStream<SpanReader&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
919
140k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
140k
    } else {
932
140k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
140k
    }
934
140k
}
void Unserialize<DataStream, COutPoint, std::allocator<COutPoint>>(DataStream&, std::vector<COutPoint, std::allocator<COutPoint>>&)
Line
Count
Source
919
2
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
2
    } else {
932
2
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
2
    }
934
2
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>(ParamsStream<BufferedFile&, TransactionSerParams>&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
919
1.91k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
1.91k
    } else {
932
1.91k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
1.91k
    }
934
1.91k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, CTxIn, std::allocator<CTxIn>>(ParamsStream<BufferedFile&, TransactionSerParams>&, std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
919
3.98k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
3.98k
    } else {
932
3.98k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
3.98k
    }
934
3.98k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, CTxOut, std::allocator<CTxOut>>(ParamsStream<BufferedFile&, TransactionSerParams>&, std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
919
2.01k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
2.01k
    } else {
932
2.01k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
2.01k
    }
934
2.01k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>(ParamsStream<BufferedFile&, TransactionSerParams>&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
919
1.97k
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
1.97k
    } else {
932
1.97k
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
1.97k
    }
934
1.97k
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, unsigned char, std::allocator<unsigned char>>(ParamsStream<BufferedFile&, TransactionSerParams>&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
919
2.05k
{
920
2.05k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
2.05k
        v.clear();
923
2.05k
        unsigned int nSize = ReadCompactSize(is);
924
2.05k
        unsigned int i = 0;
925
4.10k
        while (i < nSize) {
926
2.05k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
2.05k
            v.resize(i + blk);
928
2.05k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
2.05k
            i += blk;
930
2.05k
        }
931
    } else {
932
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
    }
934
2.05k
}
void Unserialize<DataStream, unsigned int, std::allocator<unsigned int>>(DataStream&, std::vector<unsigned int, std::allocator<unsigned int>>&)
Line
Count
Source
919
277
{
920
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
        v.clear();
923
        unsigned int nSize = ReadCompactSize(is);
924
        unsigned int i = 0;
925
        while (i < nSize) {
926
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
            v.resize(i + blk);
928
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
            i += blk;
930
        }
931
277
    } else {
932
277
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
277
    }
934
277
}
void Unserialize<DataStream, unsigned char, secure_allocator<unsigned char>>(DataStream&, std::vector<unsigned char, secure_allocator<unsigned char>>&)
Line
Count
Source
919
2.89k
{
920
2.89k
    if constexpr (BasicByte<T>) { // Use optimized version for unformatted basic bytes
921
        // Limit size per read so bogus size value won't cause out of memory
922
2.89k
        v.clear();
923
2.89k
        unsigned int nSize = ReadCompactSize(is);
924
2.89k
        unsigned int i = 0;
925
5.78k
        while (i < nSize) {
926
2.89k
            unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
927
2.89k
            v.resize(i + blk);
928
2.89k
            is.read(std::as_writable_bytes(std::span{&v[i], blk}));
929
2.89k
            i += blk;
930
2.89k
        }
931
    } else {
932
        Unserialize(is, Using<VectorFormatter<DefaultFormatter>>(v));
933
    }
934
2.89k
}
935
936
937
/**
938
 * pair
939
 */
940
template<typename Stream, typename K, typename T>
941
void Serialize(Stream& os, const std::pair<K, T>& item)
942
548k
{
943
548k
    Serialize(os, item.first);
944
548k
    Serialize(os, item.second);
945
548k
}
void Serialize<DataStream, unsigned char, uint256>(DataStream&, std::pair<unsigned char, uint256> const&)
Line
Count
Source
942
120k
{
943
120k
    Serialize(os, item.first);
944
120k
    Serialize(os, item.second);
945
120k
}
void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int> const&)
Line
Count
Source
942
166
{
943
166
    Serialize(os, item.first);
944
166
    Serialize(os, item.second);
945
166
}
void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
Line
Count
Source
942
56.8k
{
943
56.8k
    Serialize(os, item.first);
944
56.8k
    Serialize(os, item.second);
945
56.8k
}
void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
Line
Count
Source
942
74.6k
{
943
74.6k
    Serialize(os, item.first);
944
74.6k
    Serialize(os, item.second);
945
74.6k
}
void Serialize<DataStream, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, uint256>, unsigned int>(DataStream&, std::pair<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, uint256>, unsigned int> const&)
Line
Count
Source
942
10.1k
{
943
10.1k
    Serialize(os, item.first);
944
10.1k
    Serialize(os, item.second);
945
10.1k
}
void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, uint256>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, uint256> const&)
Line
Count
Source
942
137k
{
943
137k
    Serialize(os, item.first);
944
137k
    Serialize(os, item.second);
945
137k
}
blockfilterindex.cpp:void Serialize<DataStream, uint256, (anonymous namespace)::DBVal>(DataStream&, std::pair<uint256, (anonymous namespace)::DBVal> const&)
Line
Count
Source
942
8.00k
{
943
8.00k
    Serialize(os, item.first);
944
8.00k
    Serialize(os, item.second);
945
8.00k
}
coinstatsindex.cpp:void Serialize<DataStream, uint256, (anonymous namespace)::DBVal>(DataStream&, std::pair<uint256, (anonymous namespace)::DBVal> const&)
Line
Count
Source
942
4.10k
{
943
4.10k
    Serialize(os, item.first);
944
4.10k
    Serialize(os, item.second);
945
4.10k
}
void Serialize<DataStream, unsigned long, unsigned long>(DataStream&, std::pair<unsigned long, unsigned long> const&)
Line
Count
Source
942
31
{
943
31
    Serialize(os, item.first);
944
31
    Serialize(os, item.second);
945
31
}
void Serialize<DataStream, unsigned char, unsigned long>(DataStream&, std::pair<unsigned char, unsigned long> const&)
Line
Count
Source
942
36
{
943
36
    Serialize(os, item.first);
944
36
    Serialize(os, item.second);
945
36
}
void Serialize<DataStream, unsigned char, int>(DataStream&, std::pair<unsigned char, int> const&)
Line
Count
Source
942
4.37k
{
943
4.37k
    Serialize(os, item.first);
944
4.37k
    Serialize(os, item.second);
945
4.37k
}
void Serialize<DataStream, unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(DataStream&, std::pair<unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
Line
Count
Source
942
1.32k
{
943
1.32k
    Serialize(os, item.first);
944
1.32k
    Serialize(os, item.second);
945
1.32k
}
void Serialize<AutoFile, transaction_identifier<false> const, long>(AutoFile&, std::pair<transaction_identifier<false> const, long> const&)
Line
Count
Source
942
255
{
943
255
    Serialize(os, item.first);
944
255
    Serialize(os, item.second);
945
255
}
void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, transaction_identifier<false>>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, transaction_identifier<false>> const&)
Line
Count
Source
942
24.6k
{
943
24.6k
    Serialize(os, item.first);
944
24.6k
    Serialize(os, item.second);
945
24.6k
}
void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<transaction_identifier<false>, transaction_identifier<true>>>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<transaction_identifier<false>, transaction_identifier<true>>> const&)
Line
Count
Source
942
18.2k
{
943
18.2k
    Serialize(os, item.first);
944
18.2k
    Serialize(os, item.second);
945
18.2k
}
void Serialize<DataStream, transaction_identifier<false>, transaction_identifier<true>>(DataStream&, std::pair<transaction_identifier<false>, transaction_identifier<true>> const&)
Line
Count
Source
942
18.2k
{
943
18.2k
    Serialize(os, item.first);
944
18.2k
    Serialize(os, item.second);
945
18.2k
}
void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CPubKey>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CPubKey> const&)
Line
Count
Source
942
180
{
943
180
    Serialize(os, item.first);
944
180
    Serialize(os, item.second);
945
180
}
void Serialize<DataStream, std::vector<unsigned char, secure_allocator<unsigned char>>, uint256>(DataStream&, std::pair<std::vector<unsigned char, secure_allocator<unsigned char>>, uint256> const&)
Line
Count
Source
942
4.79k
{
943
4.79k
    Serialize(os, item.first);
944
4.79k
    Serialize(os, item.second);
945
4.79k
}
void Serialize<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>, uint256>(DataStream&, std::pair<std::vector<unsigned char, std::allocator<unsigned char>>, uint256> const&)
Line
Count
Source
942
60
{
943
60
    Serialize(os, item.first);
944
60
    Serialize(os, item.second);
945
60
}
Unexecuted instantiation: void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CScript>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CScript> const&)
void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned char>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned char> const&)
Line
Count
Source
942
4.65k
{
943
4.65k
    Serialize(os, item.first);
944
4.65k
    Serialize(os, item.second);
945
4.65k
}
void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<uint256, CPubKey>>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<uint256, CPubKey>> const&)
Line
Count
Source
942
5.69k
{
943
5.69k
    Serialize(os, item.first);
944
5.69k
    Serialize(os, item.second);
945
5.69k
}
void Serialize<DataStream, uint256, CPubKey>(DataStream&, std::pair<uint256, CPubKey> const&)
Line
Count
Source
942
5.69k
{
943
5.69k
    Serialize(os, item.first);
944
5.69k
    Serialize(os, item.second);
945
5.69k
}
void Serialize<DataStream, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, uint256>, std::pair<unsigned int, unsigned int>>(DataStream&, std::pair<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, uint256>, std::pair<unsigned int, unsigned int>> const&)
Line
Count
Source
942
24.0k
{
943
24.0k
    Serialize(os, item.first);
944
24.0k
    Serialize(os, item.second);
945
24.0k
}
void Serialize<DataStream, unsigned int, unsigned int>(DataStream&, std::pair<unsigned int, unsigned int> const&)
Line
Count
Source
942
24.0k
{
943
24.0k
    Serialize(os, item.first);
944
24.0k
    Serialize(os, item.second);
945
24.0k
}
void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<transaction_identifier<false>, unsigned int>>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<transaction_identifier<false>, unsigned int>> const&)
Line
Count
Source
942
4
{
943
4
    Serialize(os, item.first);
944
4
    Serialize(os, item.second);
945
4
}
void Serialize<DataStream, transaction_identifier<false>, unsigned int>(DataStream&, std::pair<transaction_identifier<false>, unsigned int> const&)
Line
Count
Source
942
4
{
943
4
    Serialize(os, item.first);
944
4
    Serialize(os, item.second);
945
4
}
void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
Line
Count
Source
942
57
{
943
57
    Serialize(os, item.first);
944
57
    Serialize(os, item.second);
945
57
}
946
947
template<typename Stream, typename K, typename T>
948
void Unserialize(Stream& is, std::pair<K, T>& item)
949
192k
{
950
192k
    Unserialize(is, item.first);
951
192k
    Unserialize(is, item.second);
952
192k
}
void Unserialize<DataStream, uint256, unsigned char>(DataStream&, std::pair<uint256, unsigned char>&)
Line
Count
Source
949
2
{
950
2
    Unserialize(is, item.first);
951
2
    Unserialize(is, item.second);
952
2
}
void Unserialize<SpanReader, unsigned long, unsigned long>(SpanReader&, std::pair<unsigned long, unsigned long>&)
Line
Count
Source
949
46
{
950
46
    Unserialize(is, item.first);
951
46
    Unserialize(is, item.second);
952
46
}
void Unserialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(DataStream&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&)
Line
Count
Source
949
35.0k
{
950
35.0k
    Unserialize(is, item.first);
951
35.0k
    Unserialize(is, item.second);
952
35.0k
}
blockfilterindex.cpp:void Unserialize<DataStream, uint256, (anonymous namespace)::DBVal>(DataStream&, std::pair<uint256, (anonymous namespace)::DBVal>&)
Line
Count
Source
949
2.97k
{
950
2.97k
    Unserialize(is, item.first);
951
2.97k
    Unserialize(is, item.second);
952
2.97k
}
blockfilterindex.cpp:void Unserialize<SpanReader, uint256, (anonymous namespace)::DBVal>(SpanReader&, std::pair<uint256, (anonymous namespace)::DBVal>&)
Line
Count
Source
949
1.02k
{
950
1.02k
    Unserialize(is, item.first);
951
1.02k
    Unserialize(is, item.second);
952
1.02k
}
coinstatsindex.cpp:void Unserialize<DataStream, uint256, (anonymous namespace)::DBVal>(DataStream&, std::pair<uint256, (anonymous namespace)::DBVal>&)
Line
Count
Source
949
121
{
950
121
    Unserialize(is, item.first);
951
121
    Unserialize(is, item.second);
952
121
}
coinstatsindex.cpp:void Unserialize<SpanReader, uint256, (anonymous namespace)::DBVal>(SpanReader&, std::pair<uint256, (anonymous namespace)::DBVal>&)
Line
Count
Source
949
222
{
950
222
    Unserialize(is, item.first);
951
222
    Unserialize(is, item.second);
952
222
}
void Unserialize<SpanReader, unsigned char, uint256>(SpanReader&, std::pair<unsigned char, uint256>&)
Line
Count
Source
949
153k
{
950
153k
    Unserialize(is, item.first);
951
153k
    Unserialize(is, item.second);
952
153k
}
void Unserialize<AutoFile, transaction_identifier<false>, long>(AutoFile&, std::pair<transaction_identifier<false>, long>&)
Line
Count
Source
949
22
{
950
22
    Unserialize(is, item.first);
951
22
    Unserialize(is, item.second);
952
22
}
953
954
955
956
/**
957
 * map
958
 */
959
template<typename Stream, typename K, typename T, typename Pred, typename A>
960
void Serialize(Stream& os, const std::map<K, T, Pred, A>& m)
961
25.7k
{
962
25.7k
    WriteCompactSize(os, m.size());
963
25.7k
    for (const auto& entry : m)
964
74.9k
        Serialize(os, entry);
965
25.7k
}
void Serialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(DataStream&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
Line
Count
Source
961
24.7k
{
962
24.7k
    WriteCompactSize(os, m.size());
963
24.7k
    for (const auto& entry : m)
964
74.6k
        Serialize(os, entry);
965
24.7k
}
void Serialize<AutoFile, transaction_identifier<false>, long, std::less<transaction_identifier<false>>, std::allocator<std::pair<transaction_identifier<false> const, long>>>(AutoFile&, std::map<transaction_identifier<false>, long, std::less<transaction_identifier<false>>, std::allocator<std::pair<transaction_identifier<false> const, long>>> const&)
Line
Count
Source
961
1.02k
{
962
1.02k
    WriteCompactSize(os, m.size());
963
1.02k
    for (const auto& entry : m)
964
255
        Serialize(os, entry);
965
1.02k
}
966
967
template<typename Stream, typename K, typename T, typename Pred, typename A>
968
void Unserialize(Stream& is, std::map<K, T, Pred, A>& m)
969
12.0k
{
970
12.0k
    m.clear();
971
12.0k
    unsigned int nSize = ReadCompactSize(is);
972
12.0k
    typename std::map<K, T, Pred, A>::iterator mi = m.begin();
973
47.1k
    for (unsigned int i = 0; i < nSize; i++)
974
35.1k
    {
975
35.1k
        std::pair<K, T> item;
976
35.1k
        Unserialize(is, item);
977
35.1k
        mi = m.insert(mi, item);
978
35.1k
    }
979
12.0k
}
void Unserialize<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(DataStream&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
Line
Count
Source
969
11.4k
{
970
11.4k
    m.clear();
971
11.4k
    unsigned int nSize = ReadCompactSize(is);
972
11.4k
    typename std::map<K, T, Pred, A>::iterator mi = m.begin();
973
46.5k
    for (unsigned int i = 0; i < nSize; i++)
974
35.0k
    {
975
35.0k
        std::pair<K, T> item;
976
35.0k
        Unserialize(is, item);
977
35.0k
        mi = m.insert(mi, item);
978
35.0k
    }
979
11.4k
}
void Unserialize<AutoFile, transaction_identifier<false>, long, std::less<transaction_identifier<false>>, std::allocator<std::pair<transaction_identifier<false> const, long>>>(AutoFile&, std::map<transaction_identifier<false>, long, std::less<transaction_identifier<false>>, std::allocator<std::pair<transaction_identifier<false> const, long>>>&)
Line
Count
Source
969
512
{
970
512
    m.clear();
971
512
    unsigned int nSize = ReadCompactSize(is);
972
512
    typename std::map<K, T, Pred, A>::iterator mi = m.begin();
973
534
    for (unsigned int i = 0; i < nSize; i++)
974
22
    {
975
22
        std::pair<K, T> item;
976
22
        Unserialize(is, item);
977
22
        mi = m.insert(mi, item);
978
22
    }
979
512
}
980
981
982
983
/**
984
 * set
985
 */
986
template<typename Stream, typename K, typename Pred, typename A>
987
void Serialize(Stream& os, const std::set<K, Pred, A>& m)
988
6.73k
{
989
6.73k
    WriteCompactSize(os, m.size());
990
11.3k
    for (typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
991
4.63k
        Serialize(os, (*it));
992
6.73k
}
void Serialize<VectorWriter, uint256, std::less<uint256>, std::allocator<uint256>>(VectorWriter&, std::set<uint256, std::less<uint256>, std::allocator<uint256>> const&)
Line
Count
Source
988
5.70k
{
989
5.70k
    WriteCompactSize(os, m.size());
990
9.79k
    for (typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
991
4.08k
        Serialize(os, (*it));
992
5.70k
}
void Serialize<AutoFile, transaction_identifier<false>, std::less<transaction_identifier<false>>, std::allocator<transaction_identifier<false>>>(AutoFile&, std::set<transaction_identifier<false>, std::less<transaction_identifier<false>>, std::allocator<transaction_identifier<false>>> const&)
Line
Count
Source
988
1.02k
{
989
1.02k
    WriteCompactSize(os, m.size());
990
1.57k
    for (typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
991
548
        Serialize(os, (*it));
992
1.02k
}
993
994
template<typename Stream, typename K, typename Pred, typename A>
995
void Unserialize(Stream& is, std::set<K, Pred, A>& m)
996
10.7k
{
997
10.7k
    m.clear();
998
10.7k
    unsigned int nSize = ReadCompactSize(is);
999
10.7k
    typename std::set<K, Pred, A>::iterator it = m.begin();
1000
18.2k
    for (unsigned int i = 0; i < nSize; i++)
1001
7.53k
    {
1002
7.53k
        K key;
1003
7.53k
        Unserialize(is, key);
1004
7.53k
        it = m.insert(it, key);
1005
7.53k
    }
1006
10.7k
}
Unexecuted instantiation: void Unserialize<DataStream, uint256, std::less<uint256>, std::allocator<uint256>>(DataStream&, std::set<uint256, std::less<uint256>, std::allocator<uint256>>&)
void Unserialize<AutoFile, transaction_identifier<false>, std::less<transaction_identifier<false>>, std::allocator<transaction_identifier<false>>>(AutoFile&, std::set<transaction_identifier<false>, std::less<transaction_identifier<false>>, std::allocator<transaction_identifier<false>>>&)
Line
Count
Source
996
512
{
997
512
    m.clear();
998
512
    unsigned int nSize = ReadCompactSize(is);
999
512
    typename std::set<K, Pred, A>::iterator it = m.begin();
1000
707
    for (unsigned int i = 0; i < nSize; i++)
1001
195
    {
1002
195
        K key;
1003
195
        Unserialize(is, key);
1004
195
        it = m.insert(it, key);
1005
195
    }
1006
512
}
void Unserialize<SpanReader, uint256, std::less<uint256>, std::allocator<uint256>>(SpanReader&, std::set<uint256, std::less<uint256>, std::allocator<uint256>>&)
Line
Count
Source
996
10.1k
{
997
10.1k
    m.clear();
998
10.1k
    unsigned int nSize = ReadCompactSize(is);
999
10.1k
    typename std::set<K, Pred, A>::iterator it = m.begin();
1000
17.5k
    for (unsigned int i = 0; i < nSize; i++)
1001
7.33k
    {
1002
7.33k
        K key;
1003
7.33k
        Unserialize(is, key);
1004
7.33k
        it = m.insert(it, key);
1005
7.33k
    }
1006
10.1k
}
1007
1008
1009
1010
/**
1011
 * unique_ptr
1012
 */
1013
template<typename Stream, typename T> void
1014
Serialize(Stream& os, const std::unique_ptr<const T>& p)
1015
{
1016
    Serialize(os, *p);
1017
}
1018
1019
template<typename Stream, typename T>
1020
void Unserialize(Stream& is, std::unique_ptr<const T>& p)
1021
{
1022
    p.reset(new T(deserialize, is));
1023
}
1024
1025
1026
1027
/**
1028
 * shared_ptr
1029
 */
1030
template<typename Stream, typename T> void
1031
Serialize(Stream& os, const std::shared_ptr<const T>& p)
1032
1.37M
{
1033
1.37M
    Serialize(os, *p);
1034
1.37M
}
void Serialize<ParamsStream<SizeComputer&, TransactionSerParams>, CTransaction>(ParamsStream<SizeComputer&, TransactionSerParams>&, std::shared_ptr<CTransaction const> const&)
Line
Count
Source
1032
1.13M
{
1033
1.13M
    Serialize(os, *p);
1034
1.13M
}
void Serialize<ParamsStream<DataStream&, TransactionSerParams>, CTransaction>(ParamsStream<DataStream&, TransactionSerParams>&, std::shared_ptr<CTransaction const> const&)
Line
Count
Source
1032
43.6k
{
1033
43.6k
    Serialize(os, *p);
1034
43.6k
}
void Serialize<ParamsStream<VectorWriter&, TransactionSerParams>, CTransaction>(ParamsStream<VectorWriter&, TransactionSerParams>&, std::shared_ptr<CTransaction const> const&)
Line
Count
Source
1032
45.3k
{
1033
45.3k
    Serialize(os, *p);
1034
45.3k
}
void Serialize<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CTransaction>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, std::shared_ptr<CTransaction const> const&)
Line
Count
Source
1032
153k
{
1033
153k
    Serialize(os, *p);
1034
153k
}
1035
1036
template<typename Stream, typename T>
1037
void Unserialize(Stream& is, std::shared_ptr<const T>& p)
1038
311k
{
1039
311k
    p = std::make_shared<const T>(deserialize, is);
1040
311k
}
void Unserialize<ParamsStream<DataStream&, TransactionSerParams>, CTransaction>(ParamsStream<DataStream&, TransactionSerParams>&, std::shared_ptr<CTransaction const>&)
Line
Count
Source
1038
115k
{
1039
115k
    p = std::make_shared<const T>(deserialize, is);
1040
115k
}
void Unserialize<ParamsStream<SpanReader&, TransactionSerParams>, CTransaction>(ParamsStream<SpanReader&, TransactionSerParams>&, std::shared_ptr<CTransaction const>&)
Line
Count
Source
1038
193k
{
1039
193k
    p = std::make_shared<const T>(deserialize, is);
1040
193k
}
void Unserialize<ParamsStream<AutoFile&, TransactionSerParams>, CTransaction>(ParamsStream<AutoFile&, TransactionSerParams>&, std::shared_ptr<CTransaction const>&)
Line
Count
Source
1038
500
{
1039
500
    p = std::make_shared<const T>(deserialize, is);
1040
500
}
void Unserialize<ParamsStream<BufferedFile&, TransactionSerParams>, CTransaction>(ParamsStream<BufferedFile&, TransactionSerParams>&, std::shared_ptr<CTransaction const>&)
Line
Count
Source
1038
2.01k
{
1039
2.01k
    p = std::make_shared<const T>(deserialize, is);
1040
2.01k
}
1041
1042
/**
1043
 * Support for (un)serializing many things at once
1044
 */
1045
1046
template <typename Stream, typename... Args>
1047
void SerializeMany(Stream& s, const Args&... args)
1048
126M
{
1049
126M
    (::Serialize(s, args), ...);
1050
126M
}
void SerializeMany<ParamsStream<SizeComputer&, TransactionSerParams>, COutPoint, CScript, unsigned int>(ParamsStream<SizeComputer&, TransactionSerParams>&, COutPoint const&, CScript const&, unsigned int const&)
Line
Count
Source
1048
4.47M
{
1049
4.47M
    (::Serialize(s, args), ...);
1050
4.47M
}
void SerializeMany<ParamsStream<SizeComputer&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>>(ParamsStream<SizeComputer&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1048
11.6M
{
1049
11.6M
    (::Serialize(s, args), ...);
1050
11.6M
}
void SerializeMany<ParamsStream<SizeComputer&, TransactionSerParams>, transaction_identifier<false>, unsigned int>(ParamsStream<SizeComputer&, TransactionSerParams>&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1048
4.47M
{
1049
4.47M
    (::Serialize(s, args), ...);
1050
4.47M
}
void SerializeMany<ParamsStream<SizeComputer&, TransactionSerParams>, long, CScript>(ParamsStream<SizeComputer&, TransactionSerParams>&, long const&, CScript const&)
Line
Count
Source
1048
7.16M
{
1049
7.16M
    (::Serialize(s, args), ...);
1050
7.16M
}
void SerializeMany<ParamsStream<SizeComputer&, TransactionSerParams>, CBlockHeader, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<SizeComputer&, TransactionSerParams>&, CBlockHeader const&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
1048
710k
{
1049
710k
    (::Serialize(s, args), ...);
1050
710k
}
void SerializeMany<ParamsStream<SizeComputer&, TransactionSerParams>, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(ParamsStream<SizeComputer&, TransactionSerParams>&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1048
710k
{
1049
710k
    (::Serialize(s, args), ...);
1050
710k
}
void SerializeMany<ParamsStream<DataStream&, CAddress::SerParams>, CAddress, CNetAddr, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>, int>(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress const&, CNetAddr const&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> const&, int const&)
Line
Count
Source
1048
17
{
1049
17
    (::Serialize(s, args), ...);
1050
17
}
void SerializeMany<ParamsStream<DataStream&, CAddress::SerParams>, unsigned int>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned int const&)
Line
Count
Source
1048
17
{
1049
17
    (::Serialize(s, args), ...);
1050
17
}
void SerializeMany<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>>(ParamsStream<DataStream&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> const&)
Line
Count
Source
1048
23
{
1049
23
    (::Serialize(s, args), ...);
1050
23
}
void SerializeMany<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(ParamsStream<DataStream&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&> const&)
Line
Count
Source
1048
18
{
1049
18
    (::Serialize(s, args), ...);
1050
18
}
void SerializeMany<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>>(ParamsStream<DataStream&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&> const&)
Line
Count
Source
1048
5
{
1049
5
    (::Serialize(s, args), ...);
1050
5
}
void SerializeMany<ParamsStream<DataStream&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService const>>(ParamsStream<DataStream&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService const> const&)
Line
Count
Source
1048
23
{
1049
23
    (::Serialize(s, args), ...);
1050
23
}
void SerializeMany<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr const&, Wrapper<CustomUintFormatter<2, true>, unsigned short const&> const&)
Line
Count
Source
1048
23
{
1049
23
    (::Serialize(s, args), ...);
1050
23
}
void SerializeMany<DataStream, CBlockHeader, unsigned long, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>>(DataStream&, CBlockHeader const&, unsigned long const&, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&> const&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
1048
9
{
1049
9
    (::Serialize(s, args), ...);
1050
9
}
void SerializeMany<DataStream, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(DataStream&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1048
97.0k
{
1049
97.0k
    (::Serialize(s, args), ...);
1050
97.0k
}
void SerializeMany<DataStream, Wrapper<CompactSizeFormatter<true>, unsigned short const&>, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>>(DataStream&, Wrapper<CompactSizeFormatter<true>, unsigned short const&> const&, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>> const&)
Line
Count
Source
1048
11
{
1049
11
    (::Serialize(s, args), ...);
1050
11
}
void SerializeMany<ParamsStream<DataStream&, TransactionSerParams>, COutPoint, CScript, unsigned int>(ParamsStream<DataStream&, TransactionSerParams>&, COutPoint const&, CScript const&, unsigned int const&)
Line
Count
Source
1048
125k
{
1049
125k
    (::Serialize(s, args), ...);
1050
125k
}
void SerializeMany<ParamsStream<DataStream&, TransactionSerParams>, transaction_identifier<false>, unsigned int>(ParamsStream<DataStream&, TransactionSerParams>&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1048
125k
{
1049
125k
    (::Serialize(s, args), ...);
1050
125k
}
void SerializeMany<ParamsStream<DataStream&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>>(ParamsStream<DataStream&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1048
393k
{
1049
393k
    (::Serialize(s, args), ...);
1050
393k
}
void SerializeMany<ParamsStream<DataStream&, TransactionSerParams>, long, CScript>(ParamsStream<DataStream&, TransactionSerParams>&, long const&, CScript const&)
Line
Count
Source
1048
267k
{
1049
267k
    (::Serialize(s, args), ...);
1050
267k
}
void SerializeMany<DataStream, uint256, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&>>(DataStream&, uint256 const&, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&> const&)
Line
Count
Source
1048
2
{
1049
2
    (::Serialize(s, args), ...);
1050
2
}
void SerializeMany<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>, unsigned int, unsigned int, unsigned char>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>> const&, unsigned int const&, unsigned int const&, unsigned char const&)
Line
Count
Source
1048
3
{
1049
3
    (::Serialize(s, args), ...);
1050
3
}
void SerializeMany<DataStream, CBlockHeader, CPartialMerkleTree>(DataStream&, CBlockHeader const&, CPartialMerkleTree const&)
Line
Count
Source
1048
14
{
1049
14
    (::Serialize(s, args), ...);
1050
14
}
void SerializeMany<DataStream, unsigned int, std::vector<uint256, std::allocator<uint256>>>(DataStream&, unsigned int const&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
1048
182
{
1049
182
    (::Serialize(s, args), ...);
1050
182
}
void SerializeMany<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
1048
182
{
1049
182
    (::Serialize(s, args), ...);
1050
182
}
void SerializeMany<DataStream, Num3072>(DataStream&, Num3072 const&)
Line
Count
Source
1048
240
{
1049
240
    (::Serialize(s, args), ...);
1050
240
}
void SerializeMany<DataStream, unsigned long>(DataStream&, unsigned long const&)
Line
Count
Source
1048
20.0k
{
1049
20.0k
    (::Serialize(s, args), ...);
1050
20.0k
}
void SerializeMany<VectorWriter, ParamsWrapper<TransactionSerParams, CTransaction const>>(VectorWriter&, ParamsWrapper<TransactionSerParams, CTransaction const> const&)
Line
Count
Source
1048
13.9k
{
1049
13.9k
    (::Serialize(s, args), ...);
1050
13.9k
}
void SerializeMany<ParamsStream<VectorWriter&, TransactionSerParams>, COutPoint, CScript, unsigned int>(ParamsStream<VectorWriter&, TransactionSerParams>&, COutPoint const&, CScript const&, unsigned int const&)
Line
Count
Source
1048
69.5k
{
1049
69.5k
    (::Serialize(s, args), ...);
1050
69.5k
}
void SerializeMany<ParamsStream<VectorWriter&, TransactionSerParams>, transaction_identifier<false>, unsigned int>(ParamsStream<VectorWriter&, TransactionSerParams>&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1048
69.5k
{
1049
69.5k
    (::Serialize(s, args), ...);
1050
69.5k
}
void SerializeMany<ParamsStream<VectorWriter&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>>(ParamsStream<VectorWriter&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1048
240k
{
1049
240k
    (::Serialize(s, args), ...);
1050
240k
}
void SerializeMany<ParamsStream<VectorWriter&, TransactionSerParams>, long, CScript>(ParamsStream<VectorWriter&, TransactionSerParams>&, long const&, CScript const&)
Line
Count
Source
1048
170k
{
1049
170k
    (::Serialize(s, args), ...);
1050
170k
}
void SerializeMany<ParamsStream<HashWriter&, TransactionSerParams>, COutPoint, CScript, unsigned int>(ParamsStream<HashWriter&, TransactionSerParams>&, COutPoint const&, CScript const&, unsigned int const&)
Line
Count
Source
1048
2.10M
{
1049
2.10M
    (::Serialize(s, args), ...);
1050
2.10M
}
void SerializeMany<ParamsStream<HashWriter&, TransactionSerParams>, transaction_identifier<false>, unsigned int>(ParamsStream<HashWriter&, TransactionSerParams>&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1048
2.10M
{
1049
2.10M
    (::Serialize(s, args), ...);
1050
2.10M
}
void SerializeMany<ParamsStream<HashWriter&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>>(ParamsStream<HashWriter&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1048
5.94M
{
1049
5.94M
    (::Serialize(s, args), ...);
1050
5.94M
}
void SerializeMany<ParamsStream<HashWriter&, TransactionSerParams>, long, CScript>(ParamsStream<HashWriter&, TransactionSerParams>&, long const&, CScript const&)
Line
Count
Source
1048
3.83M
{
1049
3.83M
    (::Serialize(s, args), ...);
1050
3.83M
}
void SerializeMany<DataStream, std::array<unsigned char, 4ul>, char [12], unsigned int, unsigned char [4]>(DataStream&, std::array<unsigned char, 4ul> const&, char const (&) [12], unsigned int const&, unsigned char const (&) [4])
Line
Count
Source
1048
2
{
1049
2
    (::Serialize(s, args), ...);
1050
2
}
void SerializeMany<VectorWriter, int, unsigned long, long, unsigned long, ParamsWrapper<CAddress::SerParams, CService const>>(VectorWriter&, int const&, unsigned long const&, long const&, unsigned long const&, ParamsWrapper<CAddress::SerParams, CService const> const&)
Line
Count
Source
1048
1
{
1049
1
    (::Serialize(s, args), ...);
1050
1
}
void SerializeMany<ParamsStream<VectorWriter&, CAddress::SerParams>, CNetAddr, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr const&, Wrapper<CustomUintFormatter<2, true>, unsigned short const&> const&)
Line
Count
Source
1048
1
{
1049
1
    (::Serialize(s, args), ...);
1050
1
}
void SerializeMany<DataStream, int>(DataStream&, int const&)
Line
Count
Source
1048
143k
{
1049
143k
    (::Serialize(s, args), ...);
1050
143k
}
void SerializeMany<DataStream, bool>(DataStream&, bool const&)
Line
Count
Source
1048
1
{
1049
1
    (::Serialize(s, args), ...);
1050
1
}
void SerializeMany<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
1048
1
{
1049
1
    (::Serialize(s, args), ...);
1050
1
}
void SerializeMany<DataStream, char [16]>(DataStream&, char const (&) [16])
Line
Count
Source
1048
1
{
1049
1
    (::Serialize(s, args), ...);
1050
1
}
void SerializeMany<DataStream, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const>>(DataStream&, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const> const&)
Line
Count
Source
1048
591
{
1049
591
    (::Serialize(s, args), ...);
1050
591
}
void SerializeMany<DataStream, int, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [16], ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const>>(DataStream&, int const&, bool const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [16], ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const> const&)
Line
Count
Source
1048
1
{
1049
1
    (::Serialize(s, args), ...);
1050
1
}
void SerializeMany<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>, ParamsWrapper<serialize_tests::BaseFormat, serialize_tests::Base const>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, ParamsWrapper<serialize_tests::BaseFormat, serialize_tests::Base const> const&)
Line
Count
Source
1048
2
{
1049
2
    (::Serialize(s, args), ...);
1050
2
}
void SerializeMany<VectorWriter, unsigned char, unsigned char>(VectorWriter&, unsigned char const&, unsigned char const&)
Line
Count
Source
1048
10
{
1049
10
    (::Serialize(s, args), ...);
1050
10
}
void SerializeMany<VectorWriter, unsigned char [4]>(VectorWriter&, unsigned char const (&) [4])
Line
Count
Source
1048
2
{
1049
2
    (::Serialize(s, args), ...);
1050
2
}
void SerializeMany<VectorWriter, unsigned char, unsigned char [4], unsigned char>(VectorWriter&, unsigned char const&, unsigned char const (&) [4], unsigned char const&)
Line
Count
Source
1048
2
{
1049
2
    (::Serialize(s, args), ...);
1050
2
}
void SerializeMany<SpanWriter, unsigned char, unsigned char [4], unsigned char>(SpanWriter&, unsigned char const&, unsigned char const (&) [4], unsigned char const&)
Line
Count
Source
1048
1
{
1049
1
    (::Serialize(s, args), ...);
1050
1
}
void SerializeMany<SpanWriter, unsigned char, unsigned char>(SpanWriter&, unsigned char const&, unsigned char const&)
Line
Count
Source
1048
1
{
1049
1
    (::Serialize(s, args), ...);
1050
1
}
void SerializeMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&>, Wrapper<CustomUintFormatter<3, true>, unsigned int const&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> const&, Wrapper<CustomUintFormatter<3, true>, unsigned int const&> const&)
Line
Count
Source
1048
4.58k
{
1049
4.58k
    (::Serialize(s, args), ...);
1050
4.58k
}
void SerializeMany<DataStream, unsigned char>(DataStream&, unsigned char const&)
Line
Count
Source
1048
20.4k
{
1049
20.4k
    (::Serialize(s, args), ...);
1050
20.4k
}
void SerializeMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> const&)
Line
Count
Source
1048
443k
{
1049
443k
    (::Serialize(s, args), ...);
1050
443k
}
void SerializeMany<DataStream, Wrapper<CustomUintFormatter<5, true>, unsigned long const&>, txindex::BlockTxPosition>(DataStream&, Wrapper<CustomUintFormatter<5, true>, unsigned long const&> const&, txindex::BlockTxPosition const&)
Line
Count
Source
1048
4.57k
{
1049
4.57k
    (::Serialize(s, args), ...);
1050
4.57k
}
void SerializeMany<SizeComputer, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(SizeComputer&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1048
35.6k
{
1049
35.6k
    (::Serialize(s, args), ...);
1050
35.6k
}
void SerializeMany<DataStream, FlatFilePos, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&>>(DataStream&, FlatFilePos const&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> const&)
Line
Count
Source
1048
46
{
1049
46
    (::Serialize(s, args), ...);
1050
46
}
void SerializeMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int const&>, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)1>, int const&> const&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> const&)
Line
Count
Source
1048
8.33k
{
1049
8.33k
    (::Serialize(s, args), ...);
1050
8.33k
}
void SerializeMany<DataStream, std::vector<uint256, std::allocator<uint256>>>(DataStream&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
1048
25.7k
{
1049
25.7k
    (::Serialize(s, args), ...);
1050
25.7k
}
void SerializeMany<SizeComputer, CompactSizeWriter>(SizeComputer&, CompactSizeWriter const&)
Line
Count
Source
1048
19.3k
{
1049
19.3k
    (::Serialize(s, args), ...);
1050
19.3k
}
void SerializeMany<DataStream, CompactSizeWriter>(DataStream&, CompactSizeWriter const&)
Line
Count
Source
1048
19.3k
{
1049
19.3k
    (::Serialize(s, args), ...);
1050
19.3k
}
void SerializeMany<SizeComputer, ParamsWrapper<TransactionSerParams, CMutableTransaction>>(SizeComputer&, ParamsWrapper<TransactionSerParams, CMutableTransaction> const&)
Line
Count
Source
1048
59
{
1049
59
    (::Serialize(s, args), ...);
1050
59
}
void SerializeMany<DataStream, ParamsWrapper<TransactionSerParams, CMutableTransaction>>(DataStream&, ParamsWrapper<TransactionSerParams, CMutableTransaction> const&)
Line
Count
Source
1048
59
{
1049
59
    (::Serialize(s, args), ...);
1050
59
}
void SerializeMany<SizeComputer, unsigned char, unsigned char [4], CExtPubKey>(SizeComputer&, unsigned char const&, unsigned char const (&) [4], CExtPubKey const&)
Line
Count
Source
1048
4
{
1049
4
    (::Serialize(s, args), ...);
1050
4
}
void SerializeMany<DataStream, unsigned char, unsigned char [4], CExtPubKey>(DataStream&, unsigned char const&, unsigned char const (&) [4], CExtPubKey const&)
Line
Count
Source
1048
4
{
1049
4
    (::Serialize(s, args), ...);
1050
4
}
void SerializeMany<SizeComputer, unsigned int>(SizeComputer&, unsigned int const&)
Line
Count
Source
1048
6.27k
{
1049
6.27k
    (::Serialize(s, args), ...);
1050
6.27k
}
void SerializeMany<DataStream, unsigned int>(DataStream&, unsigned int const&)
Line
Count
Source
1048
359k
{
1049
359k
    (::Serialize(s, args), ...);
1050
359k
}
void SerializeMany<SizeComputer, unsigned char>(SizeComputer&, unsigned char const&)
Line
Count
Source
1048
2.40k
{
1049
2.40k
    (::Serialize(s, args), ...);
1050
2.40k
}
void SerializeMany<SizeComputer, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const>>(SizeComputer&, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const> const&)
Line
Count
Source
1048
590
{
1049
590
    (::Serialize(s, args), ...);
1050
590
}
void SerializeMany<SizeComputer, CTxOut>(SizeComputer&, CTxOut const&)
Line
Count
Source
1048
1.33k
{
1049
1.33k
    (::Serialize(s, args), ...);
1050
1.33k
}
void SerializeMany<SizeComputer, long, CScript>(SizeComputer&, long const&, CScript const&)
Line
Count
Source
1048
402k
{
1049
402k
    (::Serialize(s, args), ...);
1050
402k
}
void SerializeMany<SizeComputer, prevector<36u, unsigned char, unsigned int, int>>(SizeComputer&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1048
402k
{
1049
402k
    (::Serialize(s, args), ...);
1050
402k
}
void SerializeMany<DataStream, CTxOut>(DataStream&, CTxOut const&)
Line
Count
Source
1048
1.33k
{
1049
1.33k
    (::Serialize(s, args), ...);
1050
1.33k
}
void SerializeMany<DataStream, long, CScript>(DataStream&, long const&, CScript const&)
Line
Count
Source
1048
7.45k
{
1049
7.45k
    (::Serialize(s, args), ...);
1050
7.45k
}
void SerializeMany<DataStream, prevector<36u, unsigned char, unsigned int, int>>(DataStream&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1048
10.0k
{
1049
10.0k
    (::Serialize(s, args), ...);
1050
10.0k
}
void SerializeMany<SizeComputer, CompactSizeWriter, std::span<unsigned char const, 18446744073709551615ul>>(SizeComputer&, CompactSizeWriter const&, std::span<unsigned char const, 18446744073709551615ul> const&)
Line
Count
Source
1048
1.97k
{
1049
1.97k
    (::Serialize(s, args), ...);
1050
1.97k
}
void SerializeMany<DataStream, CompactSizeWriter, std::span<unsigned char const, 18446744073709551615ul>>(DataStream&, CompactSizeWriter const&, std::span<unsigned char const, 18446744073709551615ul> const&)
Line
Count
Source
1048
1.97k
{
1049
1.97k
    (::Serialize(s, args), ...);
1050
1.97k
}
void SerializeMany<SizeComputer, int>(SizeComputer&, int const&)
Line
Count
Source
1048
48
{
1049
48
    (::Serialize(s, args), ...);
1050
48
}
void SerializeMany<SizeComputer, unsigned char, XOnlyPubKey, uint256>(SizeComputer&, unsigned char const&, XOnlyPubKey const&, uint256 const&)
Line
Count
Source
1048
264
{
1049
264
    (::Serialize(s, args), ...);
1050
264
}
void SerializeMany<SizeComputer, uint256>(SizeComputer&, uint256 const&)
Line
Count
Source
1048
6.84k
{
1049
6.84k
    (::Serialize(s, args), ...);
1050
6.84k
}
void SerializeMany<DataStream, unsigned char, XOnlyPubKey, uint256>(DataStream&, unsigned char const&, XOnlyPubKey const&, uint256 const&)
Line
Count
Source
1048
264
{
1049
264
    (::Serialize(s, args), ...);
1050
264
}
void SerializeMany<DataStream, uint256>(DataStream&, uint256 const&)
Line
Count
Source
1048
268k
{
1049
268k
    (::Serialize(s, args), ...);
1050
268k
}
void SerializeMany<SizeComputer, unsigned char, std::span<unsigned char const, 18446744073709551615ul>>(SizeComputer&, unsigned char const&, std::span<unsigned char const, 18446744073709551615ul> const&)
Line
Count
Source
1048
1.03k
{
1049
1.03k
    (::Serialize(s, args), ...);
1050
1.03k
}
void SerializeMany<DataStream, unsigned char, std::span<unsigned char const, 18446744073709551615ul>>(DataStream&, unsigned char const&, std::span<unsigned char const, 18446744073709551615ul> const&)
Line
Count
Source
1048
1.03k
{
1049
1.03k
    (::Serialize(s, args), ...);
1050
1.03k
}
void SerializeMany<SizeComputer, unsigned char, XOnlyPubKey>(SizeComputer&, unsigned char const&, XOnlyPubKey const&)
Line
Count
Source
1048
5.70k
{
1049
5.70k
    (::Serialize(s, args), ...);
1050
5.70k
}
void SerializeMany<DataStream, unsigned char, XOnlyPubKey>(DataStream&, unsigned char const&, XOnlyPubKey const&)
Line
Count
Source
1048
5.70k
{
1049
5.70k
    (::Serialize(s, args), ...);
1050
5.70k
}
void SerializeMany<SizeComputer, CompactSizeWriter, std::span<unsigned char const, 18446744073709551615ul>, std::span<unsigned char const, 18446744073709551615ul>>(SizeComputer&, CompactSizeWriter const&, std::span<unsigned char const, 18446744073709551615ul> const&, std::span<unsigned char const, 18446744073709551615ul> const&)
Line
Count
Source
1048
538
{
1049
538
    (::Serialize(s, args), ...);
1050
538
}
void SerializeMany<DataStream, CompactSizeWriter, std::span<unsigned char const, 18446744073709551615ul>, std::span<unsigned char const, 18446744073709551615ul>>(DataStream&, CompactSizeWriter const&, std::span<unsigned char const, 18446744073709551615ul> const&, std::span<unsigned char const, 18446744073709551615ul> const&)
Line
Count
Source
1048
538
{
1049
538
    (::Serialize(s, args), ...);
1050
538
}
void SerializeMany<SizeComputer, CompactSizeWriter, std::span<unsigned char const, 18446744073709551615ul>, std::span<unsigned char const, 18446744073709551615ul>, uint256>(SizeComputer&, CompactSizeWriter const&, std::span<unsigned char const, 18446744073709551615ul> const&, std::span<unsigned char const, 18446744073709551615ul> const&, uint256 const&)
Line
Count
Source
1048
762
{
1049
762
    (::Serialize(s, args), ...);
1050
762
}
void SerializeMany<DataStream, CompactSizeWriter, std::span<unsigned char const, 18446744073709551615ul>, std::span<unsigned char const, 18446744073709551615ul>, uint256>(DataStream&, CompactSizeWriter const&, std::span<unsigned char const, 18446744073709551615ul> const&, std::span<unsigned char const, 18446744073709551615ul> const&, uint256 const&)
Line
Count
Source
1048
762
{
1049
762
    (::Serialize(s, args), ...);
1050
762
}
void SerializeMany<SizeComputer, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(SizeComputer&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
1048
270
{
1049
270
    (::Serialize(s, args), ...);
1050
270
}
void SerializeMany<DataStream, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(DataStream&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
1048
270
{
1049
270
    (::Serialize(s, args), ...);
1050
270
}
void SerializeMany<SizeComputer, transaction_identifier<false>>(SizeComputer&, transaction_identifier<false> const&)
Line
Count
Source
1048
1.50k
{
1049
1.50k
    (::Serialize(s, args), ...);
1050
1.50k
}
void SerializeMany<DataStream, transaction_identifier<false>>(DataStream&, transaction_identifier<false> const&)
Line
Count
Source
1048
1.50k
{
1049
1.50k
    (::Serialize(s, args), ...);
1050
1.50k
}
void SerializeMany<SizeComputer, long>(SizeComputer&, long const&)
Line
Count
Source
1048
2.32k
{
1049
2.32k
    (::Serialize(s, args), ...);
1050
2.32k
}
void SerializeMany<DataStream, long>(DataStream&, long const&)
Line
Count
Source
1048
27.6k
{
1049
27.6k
    (::Serialize(s, args), ...);
1050
27.6k
}
void SerializeMany<VectorWriter, int, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>, long, long, ParamsWrapper<CNetAddr::SerParams, CService>, long, ParamsWrapper<CNetAddr::SerParams, CService>, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, bool>(VectorWriter&, int const&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&> const&, long const&, long const&, ParamsWrapper<CNetAddr::SerParams, CService> const&, long const&, ParamsWrapper<CNetAddr::SerParams, CService> const&, unsigned long const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&, bool const&)
Line
Count
Source
1048
5
{
1049
5
    (::Serialize(s, args), ...);
1050
5
}
void SerializeMany<ParamsStream<VectorWriter&, CNetAddr::SerParams>, CNetAddr, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, CNetAddr const&, Wrapper<CustomUintFormatter<2, true>, unsigned short const&> const&)
Line
Count
Source
1048
3.48k
{
1049
3.48k
    (::Serialize(s, args), ...);
1050
3.48k
}
void SerializeMany<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, unsigned int>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, unsigned int const&)
Line
Count
Source
1048
50.3k
{
1049
50.3k
    (::Serialize(s, args), ...);
1050
50.3k
}
void SerializeMany<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> const&)
Line
Count
Source
1048
50.3k
{
1049
50.3k
    (::Serialize(s, args), ...);
1050
50.3k
}
void SerializeMany<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&> const&)
Line
Count
Source
1048
50.3k
{
1049
50.3k
    (::Serialize(s, args), ...);
1050
50.3k
}
Unexecuted instantiation: void SerializeMany<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&> const&)
void SerializeMany<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService const>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService const> const&)
Line
Count
Source
1048
50.3k
{
1049
50.3k
    (::Serialize(s, args), ...);
1050
50.3k
}
void SerializeMany<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr const&, Wrapper<CustomUintFormatter<2, true>, unsigned short const&> const&)
Line
Count
Source
1048
50.3k
{
1049
50.3k
    (::Serialize(s, args), ...);
1050
50.3k
}
void SerializeMany<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, CAddress, CNetAddr, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>, int>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CAddress const&, CNetAddr const&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> const&, int const&)
Line
Count
Source
1048
50.3k
{
1049
50.3k
    (::Serialize(s, args), ...);
1050
50.3k
}
void SerializeMany<SizeComputer, CBlockHeader, unsigned long, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>>(SizeComputer&, CBlockHeader const&, unsigned long const&, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&> const&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
1048
35.6k
{
1049
35.6k
    (::Serialize(s, args), ...);
1050
35.6k
}
void SerializeMany<SizeComputer, Wrapper<CompactSizeFormatter<true>, unsigned short const&>, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>>(SizeComputer&, Wrapper<CompactSizeFormatter<true>, unsigned short const&> const&, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>> const&)
Line
Count
Source
1048
35.7k
{
1049
35.7k
    (::Serialize(s, args), ...);
1050
35.7k
}
void SerializeMany<DataStream, uint256, uint256, FlatFilePos>(DataStream&, uint256 const&, uint256 const&, FlatFilePos const&)
Line
Count
Source
1048
8.11k
{
1049
8.11k
    (::Serialize(s, args), ...);
1050
8.11k
}
void SerializeMany<DataStream, CDiskTxPos>(DataStream&, CDiskTxPos const&)
Line
Count
Source
1048
44
{
1049
44
    (::Serialize(s, args), ...);
1050
44
}
void SerializeMany<HashWriter, transaction_identifier<false>, unsigned int>(HashWriter&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1048
21.5M
{
1049
21.5M
    (::Serialize(s, args), ...);
1050
21.5M
}
void SerializeMany<HashWriter, long, CScript>(HashWriter&, long const&, CScript const&)
Line
Count
Source
1048
14.4M
{
1049
14.4M
    (::Serialize(s, args), ...);
1050
14.4M
}
void SerializeMany<HashWriter, prevector<36u, unsigned char, unsigned int, int>>(HashWriter&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1048
15.4M
{
1049
15.4M
    (::Serialize(s, args), ...);
1050
15.4M
}
void SerializeMany<DataStream, transaction_identifier<false>, unsigned int>(DataStream&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1048
6.20k
{
1049
6.20k
    (::Serialize(s, args), ...);
1050
6.20k
}
void SerializeMany<VectorWriter, CMessageHeader>(VectorWriter&, CMessageHeader const&)
Line
Count
Source
1048
136k
{
1049
136k
    (::Serialize(s, args), ...);
1050
136k
}
void SerializeMany<VectorWriter, std::array<unsigned char, 4ul>, char [12], unsigned int, unsigned char [4]>(VectorWriter&, std::array<unsigned char, 4ul> const&, char const (&) [12], unsigned int const&, unsigned char const (&) [4])
Line
Count
Source
1048
136k
{
1049
136k
    (::Serialize(s, args), ...);
1050
136k
}
void SerializeMany<VectorWriter, bool, unsigned long>(VectorWriter&, bool const&, unsigned long const&)
Line
Count
Source
1048
1.98k
{
1049
1.98k
    (::Serialize(s, args), ...);
1050
1.98k
}
void SerializeMany<VectorWriter, CBlockHeaderAndShortTxIDs>(VectorWriter&, CBlockHeaderAndShortTxIDs const&)
Line
Count
Source
1048
18.8k
{
1049
18.8k
    (::Serialize(s, args), ...);
1050
18.8k
}
void SerializeMany<VectorWriter, CBlockHeader, unsigned long, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>>(VectorWriter&, CBlockHeader const&, unsigned long const&, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&> const&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
1048
18.8k
{
1049
18.8k
    (::Serialize(s, args), ...);
1050
18.8k
}
void SerializeMany<VectorWriter, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(VectorWriter&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1048
18.8k
{
1049
18.8k
    (::Serialize(s, args), ...);
1050
18.8k
}
void SerializeMany<VectorWriter, Wrapper<CompactSizeFormatter<true>, unsigned short const&>, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>>(VectorWriter&, Wrapper<CompactSizeFormatter<true>, unsigned short const&> const&, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>> const&)
Line
Count
Source
1048
18.8k
{
1049
18.8k
    (::Serialize(s, args), ...);
1050
18.8k
}
void SerializeMany<VectorWriter, std::vector<CInv, std::allocator<CInv>>>(VectorWriter&, std::vector<CInv, std::allocator<CInv>> const&)
Line
Count
Source
1048
58.7k
{
1049
58.7k
    (::Serialize(s, args), ...);
1050
58.7k
}
void SerializeMany<VectorWriter, unsigned int, uint256>(VectorWriter&, unsigned int const&, uint256 const&)
Line
Count
Source
1048
84.8k
{
1049
84.8k
    (::Serialize(s, args), ...);
1050
84.8k
}
void SerializeMany<VectorWriter, std::span<std::byte const, 18446744073709551615ul>>(VectorWriter&, std::span<std::byte const, 18446744073709551615ul> const&)
Line
Count
Source
1048
12.5k
{
1049
12.5k
    (::Serialize(s, args), ...);
1050
12.5k
}
void SerializeMany<VectorWriter, ParamsWrapper<TransactionSerParams, CBlock const>>(VectorWriter&, ParamsWrapper<TransactionSerParams, CBlock const> const&)
Line
Count
Source
1048
8.24k
{
1049
8.24k
    (::Serialize(s, args), ...);
1050
8.24k
}
void SerializeMany<ParamsStream<VectorWriter&, TransactionSerParams>, CBlockHeader, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<VectorWriter&, TransactionSerParams>&, CBlockHeader const&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
1048
35.0k
{
1049
35.0k
    (::Serialize(s, args), ...);
1050
35.0k
}
void SerializeMany<ParamsStream<VectorWriter&, TransactionSerParams>, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(ParamsStream<VectorWriter&, TransactionSerParams>&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1048
35.0k
{
1049
35.0k
    (::Serialize(s, args), ...);
1050
35.0k
}
void SerializeMany<VectorWriter, CMerkleBlock>(VectorWriter&, CMerkleBlock const&)
Line
Count
Source
1048
4
{
1049
4
    (::Serialize(s, args), ...);
1050
4
}
void SerializeMany<VectorWriter, CBlockHeader, CPartialMerkleTree>(VectorWriter&, CBlockHeader const&, CPartialMerkleTree const&)
Line
Count
Source
1048
4
{
1049
4
    (::Serialize(s, args), ...);
1050
4
}
void SerializeMany<VectorWriter, unsigned int, std::vector<uint256, std::allocator<uint256>>>(VectorWriter&, unsigned int const&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
1048
4
{
1049
4
    (::Serialize(s, args), ...);
1050
4
}
void SerializeMany<VectorWriter, std::vector<unsigned char, std::allocator<unsigned char>>>(VectorWriter&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
1048
4
{
1049
4
    (::Serialize(s, args), ...);
1050
4
}
void SerializeMany<VectorWriter, int, unsigned long, long, unsigned long, ParamsWrapper<CNetAddr::SerParams, CService>, unsigned long, ParamsWrapper<CNetAddr::SerParams, CService>, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, bool>(VectorWriter&, int const&, unsigned long const&, long const&, unsigned long const&, ParamsWrapper<CNetAddr::SerParams, CService> const&, unsigned long const&, ParamsWrapper<CNetAddr::SerParams, CService> const&, unsigned long const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int const&, bool const&)
Line
Count
Source
1048
1.73k
{
1049
1.73k
    (::Serialize(s, args), ...);
1050
1.73k
}
void SerializeMany<VectorWriter, unsigned int, unsigned long>(VectorWriter&, unsigned int const&, unsigned long const&)
Line
Count
Source
1048
9
{
1049
9
    (::Serialize(s, args), ...);
1050
9
}
void SerializeMany<VectorWriter, std::array<std::byte, 168ul>>(VectorWriter&, std::array<std::byte, 168ul> const&)
Line
Count
Source
1048
1
{
1049
1
    (::Serialize(s, args), ...);
1050
1
}
void SerializeMany<VectorWriter, CBlockLocator, uint256>(VectorWriter&, CBlockLocator const&, uint256 const&)
Line
Count
Source
1048
3.01k
{
1049
3.01k
    (::Serialize(s, args), ...);
1050
3.01k
}
void SerializeMany<VectorWriter, int>(VectorWriter&, int const&)
Line
Count
Source
1048
3.01k
{
1049
3.01k
    (::Serialize(s, args), ...);
1050
3.01k
}
void SerializeMany<VectorWriter, std::vector<uint256, std::allocator<uint256>>>(VectorWriter&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
1048
3.01k
{
1049
3.01k
    (::Serialize(s, args), ...);
1050
3.01k
}
void SerializeMany<VectorWriter, BlockTransactions>(VectorWriter&, BlockTransactions const&)
Line
Count
Source
1048
590
{
1049
590
    (::Serialize(s, args), ...);
1050
590
}
void SerializeMany<VectorWriter, uint256, ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>>>(VectorWriter&, uint256 const&, ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>> const&)
Line
Count
Source
1048
590
{
1049
590
    (::Serialize(s, args), ...);
1050
590
}
void SerializeMany<VectorWriter, std::vector<CBlockHeader, std::allocator<CBlockHeader>>>(VectorWriter&, std::vector<CBlockHeader, std::allocator<CBlockHeader>> const&)
Line
Count
Source
1048
9
{
1049
9
    (::Serialize(s, args), ...);
1050
9
}
void SerializeMany<VectorWriter, ParamsWrapper<TransactionSerParams, std::vector<CBlock, std::allocator<CBlock>>>>(VectorWriter&, ParamsWrapper<TransactionSerParams, std::vector<CBlock, std::allocator<CBlock>>> const&)
Line
Count
Source
1048
5.27k
{
1049
5.27k
    (::Serialize(s, args), ...);
1050
5.27k
}
void SerializeMany<VectorWriter, BlockTransactionsRequest>(VectorWriter&, BlockTransactionsRequest const&)
Line
Count
Source
1048
577
{
1049
577
    (::Serialize(s, args), ...);
1050
577
}
void SerializeMany<VectorWriter, uint256, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&>>(VectorWriter&, uint256 const&, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&> const&)
Line
Count
Source
1048
577
{
1049
577
    (::Serialize(s, args), ...);
1050
577
}
void SerializeMany<VectorWriter, unsigned long>(VectorWriter&, unsigned long const&)
Line
Count
Source
1048
10.7k
{
1049
10.7k
    (::Serialize(s, args), ...);
1050
10.7k
}
void SerializeMany<VectorWriter, BlockFilter>(VectorWriter&, BlockFilter const&)
Line
Count
Source
1048
11
{
1049
11
    (::Serialize(s, args), ...);
1050
11
}
void SerializeMany<VectorWriter, unsigned char, uint256, uint256, std::vector<uint256, std::allocator<uint256>>>(VectorWriter&, unsigned char const&, uint256 const&, uint256 const&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
1048
2
{
1049
2
    (::Serialize(s, args), ...);
1050
2
}
void SerializeMany<VectorWriter, unsigned char, uint256, std::vector<uint256, std::allocator<uint256>>>(VectorWriter&, unsigned char const&, uint256 const&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
1048
3
{
1049
3
    (::Serialize(s, args), ...);
1050
3
}
void SerializeMany<VectorWriter, ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>>>>(VectorWriter&, ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>>> const&)
Line
Count
Source
1048
134
{
1049
134
    (::Serialize(s, args), ...);
1050
134
}
Unexecuted instantiation: void SerializeMany<ParamsStream<VectorWriter&, CAddress::SerParams>, unsigned int>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned int const&)
void SerializeMany<ParamsStream<VectorWriter&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> const&)
Line
Count
Source
1048
18.9k
{
1049
18.9k
    (::Serialize(s, args), ...);
1050
18.9k
}
void SerializeMany<ParamsStream<VectorWriter&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&> const&)
Line
Count
Source
1048
33
{
1049
33
    (::Serialize(s, args), ...);
1050
33
}
void SerializeMany<ParamsStream<VectorWriter&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&> const&)
Line
Count
Source
1048
18.9k
{
1049
18.9k
    (::Serialize(s, args), ...);
1050
18.9k
}
void SerializeMany<ParamsStream<VectorWriter&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService const>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService const> const&)
Line
Count
Source
1048
18.9k
{
1049
18.9k
    (::Serialize(s, args), ...);
1050
18.9k
}
void SerializeMany<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr const&, Wrapper<CustomUintFormatter<2, true>, unsigned short const&> const&)
Line
Count
Source
1048
18.9k
{
1049
18.9k
    (::Serialize(s, args), ...);
1050
18.9k
}
void SerializeMany<VectorWriter, long>(VectorWriter&, long const&)
Line
Count
Source
1048
1.80k
{
1049
1.80k
    (::Serialize(s, args), ...);
1050
1.80k
}
void SerializeMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long const&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long const&> const&)
Line
Count
Source
1048
3.44k
{
1049
3.44k
    (::Serialize(s, args), ...);
1050
3.44k
}
void SerializeMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)1>, int&> const&)
Line
Count
Source
1048
117k
{
1049
117k
    (::Serialize(s, args), ...);
1050
117k
}
void SerializeMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int const&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)1>, int const&> const&)
Line
Count
Source
1048
217k
{
1049
217k
    (::Serialize(s, args), ...);
1050
217k
}
void SerializeMany<SizeComputer, std::vector<CTxUndo, std::allocator<CTxUndo>>>(SizeComputer&, std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
1048
100k
{
1049
100k
    (::Serialize(s, args), ...);
1050
100k
}
void SerializeMany<SizeComputer, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>>(SizeComputer&, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&> const&)
Line
Count
Source
1048
45.0k
{
1049
45.0k
    (::Serialize(s, args), ...);
1050
45.0k
}
void SerializeMany<SizeComputer, Wrapper<AmountCompression, long const&>, Wrapper<ScriptCompression, CScript const&>>(SizeComputer&, Wrapper<AmountCompression, long const&> const&, Wrapper<ScriptCompression, CScript const&> const&)
Line
Count
Source
1048
69.5k
{
1049
69.5k
    (::Serialize(s, args), ...);
1050
69.5k
}
void SerializeMany<HashWriter, std::vector<CTxUndo, std::allocator<CTxUndo>>>(HashWriter&, std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
1048
100k
{
1049
100k
    (::Serialize(s, args), ...);
1050
100k
}
void SerializeMany<HashWriter, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>>(HashWriter&, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&> const&)
Line
Count
Source
1048
45.0k
{
1049
45.0k
    (::Serialize(s, args), ...);
1050
45.0k
}
void SerializeMany<HashWriter, Wrapper<AmountCompression, long const&>, Wrapper<ScriptCompression, CScript const&>>(HashWriter&, Wrapper<AmountCompression, long const&> const&, Wrapper<ScriptCompression, CScript const&> const&)
Line
Count
Source
1048
69.5k
{
1049
69.5k
    (::Serialize(s, args), ...);
1050
69.5k
}
void SerializeMany<BufferedWriter<AutoFile>, std::vector<CTxUndo, std::allocator<CTxUndo>>>(BufferedWriter<AutoFile>&, std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
1048
100k
{
1049
100k
    (::Serialize(s, args), ...);
1050
100k
}
void SerializeMany<BufferedWriter<AutoFile>, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>>(BufferedWriter<AutoFile>&, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&> const&)
Line
Count
Source
1048
45.0k
{
1049
45.0k
    (::Serialize(s, args), ...);
1050
45.0k
}
void SerializeMany<BufferedWriter<AutoFile>, Wrapper<AmountCompression, long const&>, Wrapper<ScriptCompression, CScript const&>>(BufferedWriter<AutoFile>&, Wrapper<AmountCompression, long const&> const&, Wrapper<ScriptCompression, CScript const&> const&)
Line
Count
Source
1048
69.5k
{
1049
69.5k
    (::Serialize(s, args), ...);
1050
69.5k
}
void SerializeMany<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CBlockHeader, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, CBlockHeader const&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
1048
102k
{
1049
102k
    (::Serialize(s, args), ...);
1050
102k
}
void SerializeMany<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1048
102k
{
1049
102k
    (::Serialize(s, args), ...);
1050
102k
}
void SerializeMany<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, COutPoint, CScript, unsigned int>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, COutPoint const&, CScript const&, unsigned int const&)
Line
Count
Source
1048
185k
{
1049
185k
    (::Serialize(s, args), ...);
1050
185k
}
void SerializeMany<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, transaction_identifier<false>, unsigned int>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1048
185k
{
1049
185k
    (::Serialize(s, args), ...);
1050
185k
}
void SerializeMany<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1048
567k
{
1049
567k
    (::Serialize(s, args), ...);
1050
567k
}
void SerializeMany<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, long, CScript>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, long const&, CScript const&)
Line
Count
Source
1048
381k
{
1049
381k
    (::Serialize(s, args), ...);
1050
381k
}
void SerializeMany<ParamsStream<AutoFile&, TransactionSerParams>, COutPoint, CScript, unsigned int>(ParamsStream<AutoFile&, TransactionSerParams>&, COutPoint const&, CScript const&, unsigned int const&)
Line
Count
Source
1048
2.38k
{
1049
2.38k
    (::Serialize(s, args), ...);
1050
2.38k
}
void SerializeMany<ParamsStream<AutoFile&, TransactionSerParams>, transaction_identifier<false>, unsigned int>(ParamsStream<AutoFile&, TransactionSerParams>&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1048
2.38k
{
1049
2.38k
    (::Serialize(s, args), ...);
1050
2.38k
}
void SerializeMany<ParamsStream<AutoFile&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>>(ParamsStream<AutoFile&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1048
4.25k
{
1049
4.25k
    (::Serialize(s, args), ...);
1050
4.25k
}
void SerializeMany<ParamsStream<AutoFile&, TransactionSerParams>, long, CScript>(ParamsStream<AutoFile&, TransactionSerParams>&, long const&, CScript const&)
Line
Count
Source
1048
1.87k
{
1049
1.87k
    (::Serialize(s, args), ...);
1050
1.87k
}
void SerializeMany<DataStream, unsigned int, unsigned int, CTxOut>(DataStream&, unsigned int const&, unsigned int const&, CTxOut const&)
Line
Count
Source
1048
2
{
1049
2
    (::Serialize(s, args), ...);
1050
2
}
void SerializeMany<AutoFile, Wrapper<AmountCompression, long const&>, Wrapper<ScriptCompression, CScript const&>>(AutoFile&, Wrapper<AmountCompression, long const&> const&, Wrapper<ScriptCompression, CScript const&> const&)
Line
Count
Source
1048
6.58k
{
1049
6.58k
    (::Serialize(s, args), ...);
1050
6.58k
}
void SerializeMany<ParamsStream<DataStream&, TransactionSerParams>, CBlockHeader, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<DataStream&, TransactionSerParams>&, CBlockHeader const&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
1048
41
{
1049
41
    (::Serialize(s, args), ...);
1050
41
}
void SerializeMany<ParamsStream<DataStream&, TransactionSerParams>, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(ParamsStream<DataStream&, TransactionSerParams>&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1048
42
{
1049
42
    (::Serialize(s, args), ...);
1050
42
}
void SerializeMany<VectorWriter, unsigned char [4], CExtPubKey>(VectorWriter&, unsigned char const (&) [4], CExtPubKey const&)
Line
Count
Source
1048
5
{
1049
5
    (::Serialize(s, args), ...);
1050
5
}
void SerializeMany<DataStream, unsigned char, transaction_identifier<false>, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(DataStream&, unsigned char const&, transaction_identifier<false> const&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> const&)
Line
Count
Source
1048
5.62M
{
1049
5.62M
    (::Serialize(s, args), ...);
1050
5.62M
}
void SerializeMany<DataStream, Wrapper<AmountCompression, long const&>, Wrapper<ScriptCompression, CScript const&>>(DataStream&, Wrapper<AmountCompression, long const&> const&, Wrapper<ScriptCompression, CScript const&> const&)
Line
Count
Source
1048
289k
{
1049
289k
    (::Serialize(s, args), ...);
1050
289k
}
void SerializeMany<HashWriter, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(HashWriter&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1048
18.6M
{
1049
18.6M
    (::Serialize(s, args), ...);
1050
18.6M
}
void SerializeMany<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, uint256>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, uint256 const&)
Line
Count
Source
1048
12.6k
{
1049
12.6k
    (::Serialize(s, args), ...);
1050
12.6k
}
void SerializeMany<DataStream, int, long>(DataStream&, int const&, long const&)
Line
Count
Source
1048
60
{
1049
60
    (::Serialize(s, args), ...);
1050
60
}
void SerializeMany<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CKeyID>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, CKeyID const&)
Line
Count
Source
1048
60
{
1049
60
    (::Serialize(s, args), ...);
1050
60
}
Unexecuted instantiation: void SerializeMany<DataStream, KeyOriginInfo>(DataStream&, KeyOriginInfo const&)
Unexecuted instantiation: void SerializeMany<DataStream, std::array<unsigned char, 4ul>, std::vector<unsigned int, std::allocator<unsigned int>>>(DataStream&, std::array<unsigned char, 4ul> const&, std::vector<unsigned int, std::allocator<unsigned int>> const&)
void SerializeMany<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>, std::vector<unsigned char, std::allocator<unsigned char>>, unsigned int, unsigned int, std::vector<unsigned char, std::allocator<unsigned char>>>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&, unsigned int const&, unsigned int const&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
1048
45
{
1049
45
    (::Serialize(s, args), ...);
1050
45
}
void SerializeMany<VectorWriter, CExtPubKey>(VectorWriter&, CExtPubKey const&)
Line
Count
Source
1048
156k
{
1049
156k
    (::Serialize(s, args), ...);
1050
156k
}
void SerializeMany<SpanWriter, transaction_identifier<false>, unsigned int>(SpanWriter&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1048
59
{
1049
59
    (::Serialize(s, args), ...);
1050
59
}
void SerializeMany<VectorWriter, CExtKey>(VectorWriter&, CExtKey const&)
Line
Count
Source
1048
1.09k
{
1049
1.09k
    (::Serialize(s, args), ...);
1050
1.09k
}
1051
1052
template <typename Stream, typename... Args>
1053
inline void UnserializeMany(Stream& s, Args&&... args)
1054
7.19M
{
1055
7.19M
    (::Unserialize(s, args), ...);
1056
7.19M
}
void UnserializeMany<DataStream, CBlockHeader&, unsigned long&, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>>&>&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&>(DataStream&, CBlockHeader&, unsigned long&, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>>&>&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&)
Line
Count
Source
1054
21.6k
{
1055
21.6k
    (::Unserialize(s, args), ...);
1056
21.6k
}
void UnserializeMany<DataStream, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(DataStream&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1054
476k
{
1055
476k
    (::Unserialize(s, args), ...);
1056
476k
}
void UnserializeMany<DataStream, Wrapper<CompactSizeFormatter<true>, unsigned short&>&, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>>&>(DataStream&, Wrapper<CompactSizeFormatter<true>, unsigned short&>&, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>>&)
Line
Count
Source
1054
21.6k
{
1055
21.6k
    (::Unserialize(s, args), ...);
1056
21.6k
}
void UnserializeMany<ParamsStream<DataStream&, TransactionSerParams>, COutPoint&, CScript&, unsigned int&>(ParamsStream<DataStream&, TransactionSerParams>&, COutPoint&, CScript&, unsigned int&)
Line
Count
Source
1054
137k
{
1055
137k
    (::Unserialize(s, args), ...);
1056
137k
}
void UnserializeMany<ParamsStream<DataStream&, TransactionSerParams>, transaction_identifier<false>&, unsigned int&>(ParamsStream<DataStream&, TransactionSerParams>&, transaction_identifier<false>&, unsigned int&)
Line
Count
Source
1054
137k
{
1055
137k
    (::Unserialize(s, args), ...);
1056
137k
}
void UnserializeMany<ParamsStream<DataStream&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>&>(ParamsStream<DataStream&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
1054
426k
{
1055
426k
    (::Unserialize(s, args), ...);
1056
426k
}
void UnserializeMany<ParamsStream<DataStream&, TransactionSerParams>, long&, CScript&>(ParamsStream<DataStream&, TransactionSerParams>&, long&, CScript&)
Line
Count
Source
1054
289k
{
1055
289k
    (::Unserialize(s, args), ...);
1056
289k
}
void UnserializeMany<DataStream, uint256&, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>>&>&>(DataStream&, uint256&, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>>&>&)
Line
Count
Source
1054
597
{
1055
597
    (::Unserialize(s, args), ...);
1056
597
}
void UnserializeMany<DataStream, COutPoint&, CScript&, unsigned int&>(DataStream&, COutPoint&, CScript&, unsigned int&)
Line
Count
Source
1054
4.79k
{
1055
4.79k
    (::Unserialize(s, args), ...);
1056
4.79k
}
void UnserializeMany<DataStream, transaction_identifier<false>&, unsigned int&>(DataStream&, transaction_identifier<false>&, unsigned int&)
Line
Count
Source
1054
4.79k
{
1055
4.79k
    (::Unserialize(s, args), ...);
1056
4.79k
}
void UnserializeMany<DataStream, prevector<36u, unsigned char, unsigned int, int>&>(DataStream&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
1054
9.76k
{
1055
9.76k
    (::Unserialize(s, args), ...);
1056
9.76k
}
void UnserializeMany<DataStream, long&, CScript&>(DataStream&, long&, CScript&)
Line
Count
Source
1054
4.78k
{
1055
4.78k
    (::Unserialize(s, args), ...);
1056
4.78k
}
void UnserializeMany<SpanReader, COutPoint&, CScript&, unsigned int&>(SpanReader&, COutPoint&, CScript&, unsigned int&)
Line
Count
Source
1054
1
{
1055
1
    (::Unserialize(s, args), ...);
1056
1
}
void UnserializeMany<SpanReader, transaction_identifier<false>&, unsigned int&>(SpanReader&, transaction_identifier<false>&, unsigned int&)
Line
Count
Source
1054
1
{
1055
1
    (::Unserialize(s, args), ...);
1056
1
}
void UnserializeMany<SpanReader, prevector<36u, unsigned char, unsigned int, int>&>(SpanReader&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
1054
8.14k
{
1055
8.14k
    (::Unserialize(s, args), ...);
1056
8.14k
}
void UnserializeMany<SpanReader, long&, CScript&>(SpanReader&, long&, CScript&)
Line
Count
Source
1054
4.78k
{
1055
4.78k
    (::Unserialize(s, args), ...);
1056
4.78k
}
void UnserializeMany<ParamsStream<DataStream&, TransactionSerParams>, CBlockHeader&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(ParamsStream<DataStream&, TransactionSerParams>&, CBlockHeader&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
1054
34.2k
{
1055
34.2k
    (::Unserialize(s, args), ...);
1056
34.2k
}
void UnserializeMany<ParamsStream<DataStream&, TransactionSerParams>, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(ParamsStream<DataStream&, TransactionSerParams>&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1054
34.2k
{
1055
34.2k
    (::Unserialize(s, args), ...);
1056
34.2k
}
void UnserializeMany<SpanReader, Wrapper<AmountCompression, long&>&, Wrapper<ScriptCompression, CScript&>&>(SpanReader&, Wrapper<AmountCompression, long&>&, Wrapper<ScriptCompression, CScript&>&)
Line
Count
Source
1054
89.6k
{
1055
89.6k
    (::Unserialize(s, args), ...);
1056
89.6k
}
void UnserializeMany<DataStream, Num3072&>(DataStream&, Num3072&)
Line
Count
Source
1054
4
{
1055
4
    (::Unserialize(s, args), ...);
1056
4
}
void UnserializeMany<DataStream, unsigned long&>(DataStream&, unsigned long&)
Line
Count
Source
1054
434
{
1055
434
    (::Unserialize(s, args), ...);
1056
434
}
Unexecuted instantiation: void UnserializeMany<ParamsStream<SpanReader&, CAddress::SerParams>, unsigned int&>(ParamsStream<SpanReader&, CAddress::SerParams>&, unsigned int&)
void UnserializeMany<ParamsStream<SpanReader&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(ParamsStream<SpanReader&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&)
Line
Count
Source
1054
7
{
1055
7
    (::Unserialize(s, args), ...);
1056
7
}
void UnserializeMany<ParamsStream<SpanReader&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>&>(ParamsStream<SpanReader&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&>&)
Line
Count
Source
1054
3
{
1055
3
    (::Unserialize(s, args), ...);
1056
3
}
void UnserializeMany<ParamsStream<SpanReader&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&>(ParamsStream<SpanReader&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&)
Line
Count
Source
1054
4
{
1055
4
    (::Unserialize(s, args), ...);
1056
4
}
void UnserializeMany<ParamsStream<SpanReader&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>&>(ParamsStream<SpanReader&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService>&)
Line
Count
Source
1054
7
{
1055
7
    (::Unserialize(s, args), ...);
1056
7
}
void UnserializeMany<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&)
Line
Count
Source
1054
7
{
1055
7
    (::Unserialize(s, args), ...);
1056
7
}
void UnserializeMany<DataStream, unsigned int&, std::vector<uint256, std::allocator<uint256>>&>(DataStream&, unsigned int&, std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
1054
168
{
1055
168
    (::Unserialize(s, args), ...);
1056
168
}
void UnserializeMany<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>&>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
1054
168
{
1055
168
    (::Unserialize(s, args), ...);
1056
168
}
void UnserializeMany<ParamsStream<SpanReader&, TransactionSerParams>, COutPoint&, CScript&, unsigned int&>(ParamsStream<SpanReader&, TransactionSerParams>&, COutPoint&, CScript&, unsigned int&)
Line
Count
Source
1054
332k
{
1055
332k
    (::Unserialize(s, args), ...);
1056
332k
}
void UnserializeMany<ParamsStream<SpanReader&, TransactionSerParams>, transaction_identifier<false>&, unsigned int&>(ParamsStream<SpanReader&, TransactionSerParams>&, transaction_identifier<false>&, unsigned int&)
Line
Count
Source
1054
332k
{
1055
332k
    (::Unserialize(s, args), ...);
1056
332k
}
void UnserializeMany<ParamsStream<SpanReader&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>&>(ParamsStream<SpanReader&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
1054
853k
{
1055
853k
    (::Unserialize(s, args), ...);
1056
853k
}
void UnserializeMany<ParamsStream<SpanReader&, TransactionSerParams>, long&, CScript&>(ParamsStream<SpanReader&, TransactionSerParams>&, long&, CScript&)
Line
Count
Source
1054
521k
{
1055
521k
    (::Unserialize(s, args), ...);
1056
521k
}
void UnserializeMany<DataStream, int&, bool&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char (&) [16], ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>&>(DataStream&, int&, bool&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char (&) [16], ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>&)
Line
Count
Source
1054
1
{
1055
1
    (::Unserialize(s, args), ...);
1056
1
}
void UnserializeMany<DataStream, int&>(DataStream&, int&)
Line
Count
Source
1054
157k
{
1055
157k
    (::Unserialize(s, args), ...);
1056
157k
}
void UnserializeMany<DataStream, bool&>(DataStream&, bool&)
Line
Count
Source
1054
279
{
1055
279
    (::Unserialize(s, args), ...);
1056
279
}
void UnserializeMany<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
1054
2
{
1055
2
    (::Unserialize(s, args), ...);
1056
2
}
void UnserializeMany<DataStream, char (&) [16]>(DataStream&, char (&) [16])
Line
Count
Source
1054
2
{
1055
2
    (::Unserialize(s, args), ...);
1056
2
}
void UnserializeMany<DataStream, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>&>(DataStream&, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>&)
Line
Count
Source
1054
2
{
1055
2
    (::Unserialize(s, args), ...);
1056
2
}
void UnserializeMany<SpanReader, unsigned char&>(SpanReader&, unsigned char&)
Line
Count
Source
1054
365
{
1055
365
    (::Unserialize(s, args), ...);
1056
365
}
void UnserializeMany<SpanReader, Wrapper<CustomUintFormatter<5, true>, unsigned long&>&, txindex::BlockTxPosition&>(SpanReader&, Wrapper<CustomUintFormatter<5, true>, unsigned long&>&, txindex::BlockTxPosition&)
Line
Count
Source
1054
326
{
1055
326
    (::Unserialize(s, args), ...);
1056
326
}
void UnserializeMany<SpanReader, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&, Wrapper<CustomUintFormatter<3, true>, unsigned int&>&>(SpanReader&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&, Wrapper<CustomUintFormatter<3, true>, unsigned int&>&)
Line
Count
Source
1054
326
{
1055
326
    (::Unserialize(s, args), ...);
1056
326
}
void UnserializeMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&, Wrapper<CustomUintFormatter<3, true>, unsigned int&>&>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&, Wrapper<CustomUintFormatter<3, true>, unsigned int&>&)
Line
Count
Source
1054
4
{
1055
4
    (::Unserialize(s, args), ...);
1056
4
}
void UnserializeMany<SpanReader, int&>(SpanReader&, int&)
Line
Count
Source
1054
203
{
1055
203
    (::Unserialize(s, args), ...);
1056
203
}
void UnserializeMany<SpanReader, std::vector<uint256, std::allocator<uint256>>&>(SpanReader&, std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
1054
110
{
1055
110
    (::Unserialize(s, args), ...);
1056
110
}
void UnserializeMany<AutoFile, Wrapper<AmountCompression, long&>&, Wrapper<ScriptCompression, CScript&>&>(AutoFile&, Wrapper<AmountCompression, long&>&, Wrapper<ScriptCompression, CScript&>&)
Line
Count
Source
1054
6.35k
{
1055
6.35k
    (::Unserialize(s, args), ...);
1056
6.35k
}
void UnserializeMany<DataStream, ParamsWrapper<TransactionSerParams, CMutableTransaction>&>(DataStream&, ParamsWrapper<TransactionSerParams, CMutableTransaction>&)
Line
Count
Source
1054
1
{
1055
1
    (::Unserialize(s, args), ...);
1056
1
}
void UnserializeMany<DataStream, unsigned int&>(DataStream&, unsigned int&)
Line
Count
Source
1054
457k
{
1055
457k
    (::Unserialize(s, args), ...);
1056
457k
}
Unexecuted instantiation: void UnserializeMany<DataStream, CompactSizeReader&>(DataStream&, CompactSizeReader&)
Unexecuted instantiation: void UnserializeMany<DataStream, unsigned char&>(DataStream&, unsigned char&)
Unexecuted instantiation: void UnserializeMany<DataStream, CTxOut&>(DataStream&, CTxOut&)
Unexecuted instantiation: void UnserializeMany<DataStream, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(DataStream&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Unexecuted instantiation: void UnserializeMany<DataStream, transaction_identifier<false>&>(DataStream&, transaction_identifier<false>&)
void UnserializeMany<SpanReader, uint256&>(SpanReader&, uint256&)
Line
Count
Source
1054
10.5k
{
1055
10.5k
    (::Unserialize(s, args), ...);
1056
10.5k
}
Unexecuted instantiation: void UnserializeMany<DataStream, XOnlyPubKey&>(DataStream&, XOnlyPubKey&)
void UnserializeMany<DataStream, uint256&>(DataStream&, uint256&)
Line
Count
Source
1054
305k
{
1055
305k
    (::Unserialize(s, args), ...);
1056
305k
}
void UnserializeMany<DataStream, long&>(DataStream&, long&)
Line
Count
Source
1054
726
{
1055
726
    (::Unserialize(s, args), ...);
1056
726
}
void UnserializeMany<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, unsigned int&>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, unsigned int&)
Line
Count
Source
1054
20.5k
{
1055
20.5k
    (::Unserialize(s, args), ...);
1056
20.5k
}
void UnserializeMany<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&)
Line
Count
Source
1054
20.5k
{
1055
20.5k
    (::Unserialize(s, args), ...);
1056
20.5k
}
void UnserializeMany<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>&>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&>&)
Line
Count
Source
1054
20.5k
{
1055
20.5k
    (::Unserialize(s, args), ...);
1056
20.5k
}
Unexecuted instantiation: void UnserializeMany<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&)
void UnserializeMany<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>&>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService>&)
Line
Count
Source
1054
20.5k
{
1055
20.5k
    (::Unserialize(s, args), ...);
1056
20.5k
}
void UnserializeMany<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&)
Line
Count
Source
1054
20.5k
{
1055
20.5k
    (::Unserialize(s, args), ...);
1056
20.5k
}
Unexecuted instantiation: void UnserializeMany<ParamsStream<AutoFile&, CAddress::SerParams>, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&, int&>(ParamsStream<AutoFile&, CAddress::SerParams>&, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&, int&)
Unexecuted instantiation: void UnserializeMany<ParamsStream<AutoFile&, CAddress::SerParams>, unsigned int&>(ParamsStream<AutoFile&, CAddress::SerParams>&, unsigned int&)
Unexecuted instantiation: void UnserializeMany<ParamsStream<AutoFile&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(ParamsStream<AutoFile&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&)
Unexecuted instantiation: void UnserializeMany<ParamsStream<AutoFile&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>&>(ParamsStream<AutoFile&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&>&)
Unexecuted instantiation: void UnserializeMany<ParamsStream<AutoFile&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&>(ParamsStream<AutoFile&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&)
Unexecuted instantiation: void UnserializeMany<ParamsStream<AutoFile&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>&>(ParamsStream<AutoFile&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService>&)
Unexecuted instantiation: void UnserializeMany<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&)
void UnserializeMany<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&, int&>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&, int&)
Line
Count
Source
1054
20.5k
{
1055
20.5k
    (::Unserialize(s, args), ...);
1056
20.5k
}
void UnserializeMany<ParamsStream<DataStream&, CAddress::SerParams>, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&, int&>(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&, int&)
Line
Count
Source
1054
14
{
1055
14
    (::Unserialize(s, args), ...);
1056
14
}
void UnserializeMany<ParamsStream<DataStream&, CAddress::SerParams>, unsigned int&>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned int&)
Line
Count
Source
1054
14
{
1055
14
    (::Unserialize(s, args), ...);
1056
14
}
void UnserializeMany<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(ParamsStream<DataStream&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&)
Line
Count
Source
1054
6.91k
{
1055
6.91k
    (::Unserialize(s, args), ...);
1056
6.91k
}
void UnserializeMany<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>&>(ParamsStream<DataStream&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&>&)
Line
Count
Source
1054
1.03k
{
1055
1.03k
    (::Unserialize(s, args), ...);
1056
1.03k
}
void UnserializeMany<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&>(ParamsStream<DataStream&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&)
Line
Count
Source
1054
5.88k
{
1055
5.88k
    (::Unserialize(s, args), ...);
1056
5.88k
}
void UnserializeMany<ParamsStream<DataStream&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>&>(ParamsStream<DataStream&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService>&)
Line
Count
Source
1054
6.91k
{
1055
6.91k
    (::Unserialize(s, args), ...);
1056
6.91k
}
void UnserializeMany<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&)
Line
Count
Source
1054
6.91k
{
1055
6.91k
    (::Unserialize(s, args), ...);
1056
6.91k
}
void UnserializeMany<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&, int&>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&, int&)
Line
Count
Source
1054
5
{
1055
5
    (::Unserialize(s, args), ...);
1056
5
}
void UnserializeMany<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, unsigned int&>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, unsigned int&)
Line
Count
Source
1054
5
{
1055
5
    (::Unserialize(s, args), ...);
1056
5
}
void UnserializeMany<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&)
Line
Count
Source
1054
4
{
1055
4
    (::Unserialize(s, args), ...);
1056
4
}
void UnserializeMany<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>&>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&>&)
Line
Count
Source
1054
3
{
1055
3
    (::Unserialize(s, args), ...);
1056
3
}
void UnserializeMany<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&)
Line
Count
Source
1054
1
{
1055
1
    (::Unserialize(s, args), ...);
1056
1
}
void UnserializeMany<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>&>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService>&)
Line
Count
Source
1054
4
{
1055
4
    (::Unserialize(s, args), ...);
1056
4
}
void UnserializeMany<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&)
Line
Count
Source
1054
4
{
1055
4
    (::Unserialize(s, args), ...);
1056
4
}
void UnserializeMany<DataStream, uint256&, uint256&, FlatFilePos&>(DataStream&, uint256&, uint256&, FlatFilePos&)
Line
Count
Source
1054
2.97k
{
1055
2.97k
    (::Unserialize(s, args), ...);
1056
2.97k
}
void UnserializeMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&)
Line
Count
Source
1054
2.97k
{
1055
2.97k
    (::Unserialize(s, args), ...);
1056
2.97k
}
void UnserializeMany<SpanReader, uint256&, uint256&, FlatFilePos&>(SpanReader&, uint256&, uint256&, FlatFilePos&)
Line
Count
Source
1054
1.06k
{
1055
1.06k
    (::Unserialize(s, args), ...);
1056
1.06k
}
void UnserializeMany<SpanReader, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&>(SpanReader&, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&)
Line
Count
Source
1054
1.12k
{
1055
1.12k
    (::Unserialize(s, args), ...);
1056
1.12k
}
void UnserializeMany<SpanReader, unsigned long&>(SpanReader&, unsigned long&)
Line
Count
Source
1054
3.54k
{
1055
3.54k
    (::Unserialize(s, args), ...);
1056
3.54k
}
void UnserializeMany<SpanReader, long&>(SpanReader&, long&)
Line
Count
Source
1054
4.39k
{
1055
4.39k
    (::Unserialize(s, args), ...);
1056
4.39k
}
void UnserializeMany<SpanReader, Num3072&>(SpanReader&, Num3072&)
Line
Count
Source
1054
64
{
1055
64
    (::Unserialize(s, args), ...);
1056
64
}
void UnserializeMany<ParamsStream<AutoFile&, TransactionSerParams>, COutPoint&, CScript&, unsigned int&>(ParamsStream<AutoFile&, TransactionSerParams>&, COutPoint&, CScript&, unsigned int&)
Line
Count
Source
1054
517
{
1055
517
    (::Unserialize(s, args), ...);
1056
517
}
void UnserializeMany<ParamsStream<AutoFile&, TransactionSerParams>, transaction_identifier<false>&, unsigned int&>(ParamsStream<AutoFile&, TransactionSerParams>&, transaction_identifier<false>&, unsigned int&)
Line
Count
Source
1054
517
{
1055
517
    (::Unserialize(s, args), ...);
1056
517
}
void UnserializeMany<ParamsStream<AutoFile&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>&>(ParamsStream<AutoFile&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
1054
1.34k
{
1055
1.34k
    (::Unserialize(s, args), ...);
1056
1.34k
}
void UnserializeMany<ParamsStream<AutoFile&, TransactionSerParams>, long&, CScript&>(ParamsStream<AutoFile&, TransactionSerParams>&, long&, CScript&)
Line
Count
Source
1054
832
{
1055
832
    (::Unserialize(s, args), ...);
1056
832
}
void UnserializeMany<SpanReader, FlatFilePos&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&>(SpanReader&, FlatFilePos&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&)
Line
Count
Source
1054
29
{
1055
29
    (::Unserialize(s, args), ...);
1056
29
}
void UnserializeMany<AutoFile, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(AutoFile&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1054
24
{
1055
24
    (::Unserialize(s, args), ...);
1056
24
}
void UnserializeMany<SpanReader, CDiskTxPos&>(SpanReader&, CDiskTxPos&)
Line
Count
Source
1054
26
{
1055
26
    (::Unserialize(s, args), ...);
1056
26
}
Unexecuted instantiation: void UnserializeMany<ParamsStream<SpanReader, CAddress::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(ParamsStream<SpanReader, CAddress::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&)
void UnserializeMany<DataStream, std::array<unsigned char, 4ul>&, char (&) [12], unsigned int&, unsigned char (&) [4]>(DataStream&, std::array<unsigned char, 4ul>&, char (&) [12], unsigned int&, unsigned char (&) [4])
Line
Count
Source
1054
129k
{
1055
129k
    (::Unserialize(s, args), ...);
1056
129k
}
void UnserializeMany<ParamsStream<DataStream&, CNetAddr::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&>(ParamsStream<DataStream&, CNetAddr::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&)
Line
Count
Source
1054
1.73k
{
1055
1.73k
    (::Unserialize(s, args), ...);
1056
1.73k
}
void UnserializeMany<DataStream, unsigned int&, uint256&>(DataStream&, unsigned int&, uint256&)
Line
Count
Source
1054
167k
{
1055
167k
    (::Unserialize(s, args), ...);
1056
167k
}
void UnserializeMany<DataStream, std::vector<uint256, std::allocator<uint256>>&>(DataStream&, std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
1054
5.20k
{
1055
5.20k
    (::Unserialize(s, args), ...);
1056
5.20k
}
void UnserializeMany<DataStream, uint256&, ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>>&>(DataStream&, uint256&, ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>>&)
Line
Count
Source
1054
572
{
1055
572
    (::Unserialize(s, args), ...);
1056
572
}
void UnserializeMany<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, unsigned char&>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, unsigned char&)
Line
Count
Source
1054
10
{
1055
10
    (::Unserialize(s, args), ...);
1056
10
}
void UnserializeMany<SpanReader, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&>(SpanReader&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&)
Line
Count
Source
1054
4.19k
{
1055
4.19k
    (::Unserialize(s, args), ...);
1056
4.19k
}
void UnserializeMany<SpanReader, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>&>(SpanReader&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>&)
Line
Count
Source
1054
1.67k
{
1055
1.67k
    (::Unserialize(s, args), ...);
1056
1.67k
}
void UnserializeMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>&>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>&)
Line
Count
Source
1054
455k
{
1055
455k
    (::Unserialize(s, args), ...);
1056
455k
}
void UnserializeMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&)
Line
Count
Source
1054
604k
{
1055
604k
    (::Unserialize(s, args), ...);
1056
604k
}
void UnserializeMany<HashVerifier<BufferedReader<AutoFile>>, std::vector<CTxUndo, std::allocator<CTxUndo>>&>(HashVerifier<BufferedReader<AutoFile>>&, std::vector<CTxUndo, std::allocator<CTxUndo>>&)
Line
Count
Source
1054
33.7k
{
1055
33.7k
    (::Unserialize(s, args), ...);
1056
33.7k
}
void UnserializeMany<HashVerifier<BufferedReader<AutoFile>>, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>>&>&>(HashVerifier<BufferedReader<AutoFile>>&, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>>&>&)
Line
Count
Source
1054
21.0k
{
1055
21.0k
    (::Unserialize(s, args), ...);
1056
21.0k
}
void UnserializeMany<HashVerifier<BufferedReader<AutoFile>>, Wrapper<AmountCompression, long&>&, Wrapper<ScriptCompression, CScript&>&>(HashVerifier<BufferedReader<AutoFile>>&, Wrapper<AmountCompression, long&>&, Wrapper<ScriptCompression, CScript&>&)
Line
Count
Source
1054
31.1k
{
1055
31.1k
    (::Unserialize(s, args), ...);
1056
31.1k
}
void UnserializeMany<ParamsStream<SpanReader&, TransactionSerParams>, CBlockHeader&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(ParamsStream<SpanReader&, TransactionSerParams>&, CBlockHeader&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
1054
140k
{
1055
140k
    (::Unserialize(s, args), ...);
1056
140k
}
void UnserializeMany<ParamsStream<SpanReader&, TransactionSerParams>, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(ParamsStream<SpanReader&, TransactionSerParams>&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1054
140k
{
1055
140k
    (::Unserialize(s, args), ...);
1056
140k
}
void UnserializeMany<SpanReader, CBlockHeader&, CPartialMerkleTree&>(SpanReader&, CBlockHeader&, CPartialMerkleTree&)
Line
Count
Source
1054
20
{
1055
20
    (::Unserialize(s, args), ...);
1056
20
}
void UnserializeMany<SpanReader, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(SpanReader&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1054
1.86k
{
1055
1.86k
    (::Unserialize(s, args), ...);
1056
1.86k
}
void UnserializeMany<SpanReader, unsigned int&, std::vector<uint256, std::allocator<uint256>>&>(SpanReader&, unsigned int&, std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
1054
20
{
1055
20
    (::Unserialize(s, args), ...);
1056
20
}
void UnserializeMany<SpanReader, std::vector<unsigned char, std::allocator<unsigned char>>&>(SpanReader&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
1054
20
{
1055
20
    (::Unserialize(s, args), ...);
1056
20
}
void UnserializeMany<SpanReader, unsigned char&, transaction_identifier<false>&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&>(SpanReader&, unsigned char&, transaction_identifier<false>&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&)
Line
Count
Source
1054
279k
{
1055
279k
    (::Unserialize(s, args), ...);
1056
279k
}
void UnserializeMany<DataStream, Wrapper<AmountCompression, long&>&, Wrapper<ScriptCompression, CScript&>&>(DataStream&, Wrapper<AmountCompression, long&>&, Wrapper<ScriptCompression, CScript&>&)
Line
Count
Source
1054
279k
{
1055
279k
    (::Unserialize(s, args), ...);
1056
279k
}
void UnserializeMany<BufferedFile, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(BufferedFile&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1054
2.02k
{
1055
2.02k
    (::Unserialize(s, args), ...);
1056
2.02k
}
void UnserializeMany<ParamsStream<BufferedFile&, TransactionSerParams>, CBlockHeader&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(ParamsStream<BufferedFile&, TransactionSerParams>&, CBlockHeader&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
1054
1.91k
{
1055
1.91k
    (::Unserialize(s, args), ...);
1056
1.91k
}
void UnserializeMany<ParamsStream<BufferedFile&, TransactionSerParams>, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(ParamsStream<BufferedFile&, TransactionSerParams>&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1054
1.91k
{
1055
1.91k
    (::Unserialize(s, args), ...);
1056
1.91k
}
void UnserializeMany<ParamsStream<BufferedFile&, TransactionSerParams>, COutPoint&, CScript&, unsigned int&>(ParamsStream<BufferedFile&, TransactionSerParams>&, COutPoint&, CScript&, unsigned int&)
Line
Count
Source
1054
2.01k
{
1055
2.01k
    (::Unserialize(s, args), ...);
1056
2.01k
}
void UnserializeMany<ParamsStream<BufferedFile&, TransactionSerParams>, transaction_identifier<false>&, unsigned int&>(ParamsStream<BufferedFile&, TransactionSerParams>&, transaction_identifier<false>&, unsigned int&)
Line
Count
Source
1054
2.01k
{
1055
2.01k
    (::Unserialize(s, args), ...);
1056
2.01k
}
void UnserializeMany<ParamsStream<BufferedFile&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>&>(ParamsStream<BufferedFile&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
1054
5.97k
{
1055
5.97k
    (::Unserialize(s, args), ...);
1056
5.97k
}
void UnserializeMany<ParamsStream<BufferedFile&, TransactionSerParams>, long&, CScript&>(ParamsStream<BufferedFile&, TransactionSerParams>&, long&, CScript&)
Line
Count
Source
1054
3.96k
{
1055
3.96k
    (::Unserialize(s, args), ...);
1056
3.96k
}
void UnserializeMany<DataStream, int&, long&>(DataStream&, int&, long&)
Line
Count
Source
1054
376
{
1055
376
    (::Unserialize(s, args), ...);
1056
376
}
void UnserializeMany<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, CKeyID&>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, CKeyID&)
Line
Count
Source
1054
376
{
1055
376
    (::Unserialize(s, args), ...);
1056
376
}
void UnserializeMany<DataStream, KeyOriginInfo&>(DataStream&, KeyOriginInfo&)
Line
Count
Source
1054
277
{
1055
277
    (::Unserialize(s, args), ...);
1056
277
}
void UnserializeMany<DataStream, std::array<unsigned char, 4ul>&, std::vector<unsigned int, std::allocator<unsigned int>>&>(DataStream&, std::array<unsigned char, 4ul>&, std::vector<unsigned int, std::allocator<unsigned int>>&)
Line
Count
Source
1054
277
{
1055
277
    (::Unserialize(s, args), ...);
1056
277
}
void UnserializeMany<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, std::vector<unsigned char, std::allocator<unsigned char>>&>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
1054
27
{
1055
27
    (::Unserialize(s, args), ...);
1056
27
}
void UnserializeMany<DataStream, int&, unsigned int&, CKeyID&>(DataStream&, int&, unsigned int&, CKeyID&)
Line
Count
Source
1054
38
{
1055
38
    (::Unserialize(s, args), ...);
1056
38
}
void UnserializeMany<SpanReader, ParamsWrapper<TransactionSerParams, CMutableTransaction>&>(SpanReader&, ParamsWrapper<TransactionSerParams, CMutableTransaction>&)
Line
Count
Source
1054
221
{
1055
221
    (::Unserialize(s, args), ...);
1056
221
}
void UnserializeMany<SpanReader, unsigned int&>(SpanReader&, unsigned int&)
Line
Count
Source
1054
8.86k
{
1055
8.86k
    (::Unserialize(s, args), ...);
1056
8.86k
}
void UnserializeMany<SpanReader, CompactSizeReader&>(SpanReader&, CompactSizeReader&)
Line
Count
Source
1054
3.30k
{
1055
3.30k
    (::Unserialize(s, args), ...);
1056
3.30k
}
void UnserializeMany<SpanReader, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>&>(SpanReader&, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>&)
Line
Count
Source
1054
489
{
1055
489
    (::Unserialize(s, args), ...);
1056
489
}
void UnserializeMany<SpanReader, CTxOut&>(SpanReader&, CTxOut&)
Line
Count
Source
1054
1.86k
{
1055
1.86k
    (::Unserialize(s, args), ...);
1056
1.86k
}
void UnserializeMany<SpanReader, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(SpanReader&, std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
1054
109
{
1055
109
    (::Unserialize(s, args), ...);
1056
109
}
void UnserializeMany<SpanReader, transaction_identifier<false>&>(SpanReader&, transaction_identifier<false>&)
Line
Count
Source
1054
1.96k
{
1055
1.96k
    (::Unserialize(s, args), ...);
1056
1.96k
}
void UnserializeMany<SpanReader, XOnlyPubKey&>(SpanReader&, XOnlyPubKey&)
Line
Count
Source
1054
2.23k
{
1055
2.23k
    (::Unserialize(s, args), ...);
1056
2.23k
}
1057
1058
/**
1059
 * Support for all macros providing or using the ser_action parameter of the SerializationOps method.
1060
 */
1061
struct ActionSerialize {
1062
0
    static constexpr bool ForRead() { return false; }
1063
1064
    template<typename Stream, typename... Args>
1065
    static void SerReadWriteMany(Stream& s, const Args&... args)
1066
126M
    {
1067
126M
        ::SerializeMany(s, args...);
1068
126M
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<SizeComputer&, TransactionSerParams>, COutPoint, CScript, unsigned int>(ParamsStream<SizeComputer&, TransactionSerParams>&, COutPoint const&, CScript const&, unsigned int const&)
Line
Count
Source
1066
4.47M
    {
1067
4.47M
        ::SerializeMany(s, args...);
1068
4.47M
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<SizeComputer&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>>(ParamsStream<SizeComputer&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1066
11.6M
    {
1067
11.6M
        ::SerializeMany(s, args...);
1068
11.6M
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<SizeComputer&, TransactionSerParams>, transaction_identifier<false>, unsigned int>(ParamsStream<SizeComputer&, TransactionSerParams>&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1066
4.47M
    {
1067
4.47M
        ::SerializeMany(s, args...);
1068
4.47M
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<SizeComputer&, TransactionSerParams>, long, CScript>(ParamsStream<SizeComputer&, TransactionSerParams>&, long const&, CScript const&)
Line
Count
Source
1066
7.16M
    {
1067
7.16M
        ::SerializeMany(s, args...);
1068
7.16M
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<SizeComputer&, TransactionSerParams>, CBlockHeader, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<SizeComputer&, TransactionSerParams>&, CBlockHeader const&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
1066
710k
    {
1067
710k
        ::SerializeMany(s, args...);
1068
710k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<SizeComputer&, TransactionSerParams>, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(ParamsStream<SizeComputer&, TransactionSerParams>&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1066
710k
    {
1067
710k
        ::SerializeMany(s, args...);
1068
710k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, CAddress::SerParams>, CAddress, CNetAddr, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>, int>(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress const&, CNetAddr const&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> const&, int const&)
Line
Count
Source
1066
17
    {
1067
17
        ::SerializeMany(s, args...);
1068
17
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, CAddress::SerParams>, unsigned int>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned int const&)
Line
Count
Source
1066
17
    {
1067
17
        ::SerializeMany(s, args...);
1068
17
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>>(ParamsStream<DataStream&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> const&)
Line
Count
Source
1066
23
    {
1067
23
        ::SerializeMany(s, args...);
1068
23
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(ParamsStream<DataStream&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&> const&)
Line
Count
Source
1066
18
    {
1067
18
        ::SerializeMany(s, args...);
1068
18
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>>(ParamsStream<DataStream&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&> const&)
Line
Count
Source
1066
5
    {
1067
5
        ::SerializeMany(s, args...);
1068
5
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService const>>(ParamsStream<DataStream&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService const> const&)
Line
Count
Source
1066
23
    {
1067
23
        ::SerializeMany(s, args...);
1068
23
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr const&, Wrapper<CustomUintFormatter<2, true>, unsigned short const&> const&)
Line
Count
Source
1066
23
    {
1067
23
        ::SerializeMany(s, args...);
1068
23
    }
void ActionSerialize::SerReadWriteMany<DataStream, CBlockHeader, unsigned long, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>>(DataStream&, CBlockHeader const&, unsigned long const&, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&> const&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
1066
9
    {
1067
9
        ::SerializeMany(s, args...);
1068
9
    }
void ActionSerialize::SerReadWriteMany<DataStream, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(DataStream&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1066
97.0k
    {
1067
97.0k
        ::SerializeMany(s, args...);
1068
97.0k
    }
void ActionSerialize::SerReadWriteMany<DataStream, Wrapper<CompactSizeFormatter<true>, unsigned short const&>, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>>(DataStream&, Wrapper<CompactSizeFormatter<true>, unsigned short const&> const&, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>> const&)
Line
Count
Source
1066
11
    {
1067
11
        ::SerializeMany(s, args...);
1068
11
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, TransactionSerParams>, COutPoint, CScript, unsigned int>(ParamsStream<DataStream&, TransactionSerParams>&, COutPoint const&, CScript const&, unsigned int const&)
Line
Count
Source
1066
125k
    {
1067
125k
        ::SerializeMany(s, args...);
1068
125k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, TransactionSerParams>, transaction_identifier<false>, unsigned int>(ParamsStream<DataStream&, TransactionSerParams>&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1066
125k
    {
1067
125k
        ::SerializeMany(s, args...);
1068
125k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>>(ParamsStream<DataStream&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1066
393k
    {
1067
393k
        ::SerializeMany(s, args...);
1068
393k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, TransactionSerParams>, long, CScript>(ParamsStream<DataStream&, TransactionSerParams>&, long const&, CScript const&)
Line
Count
Source
1066
267k
    {
1067
267k
        ::SerializeMany(s, args...);
1068
267k
    }
void ActionSerialize::SerReadWriteMany<DataStream, uint256, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&>>(DataStream&, uint256 const&, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&> const&)
Line
Count
Source
1066
2
    {
1067
2
        ::SerializeMany(s, args...);
1068
2
    }
void ActionSerialize::SerReadWriteMany<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>, unsigned int, unsigned int, unsigned char>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>> const&, unsigned int const&, unsigned int const&, unsigned char const&)
Line
Count
Source
1066
3
    {
1067
3
        ::SerializeMany(s, args...);
1068
3
    }
void ActionSerialize::SerReadWriteMany<DataStream, CBlockHeader, CPartialMerkleTree>(DataStream&, CBlockHeader const&, CPartialMerkleTree const&)
Line
Count
Source
1066
14
    {
1067
14
        ::SerializeMany(s, args...);
1068
14
    }
void ActionSerialize::SerReadWriteMany<DataStream, unsigned int, std::vector<uint256, std::allocator<uint256>>>(DataStream&, unsigned int const&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
1066
182
    {
1067
182
        ::SerializeMany(s, args...);
1068
182
    }
void ActionSerialize::SerReadWriteMany<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
1066
182
    {
1067
182
        ::SerializeMany(s, args...);
1068
182
    }
void ActionSerialize::SerReadWriteMany<DataStream, Num3072>(DataStream&, Num3072 const&)
Line
Count
Source
1066
240
    {
1067
240
        ::SerializeMany(s, args...);
1068
240
    }
void ActionSerialize::SerReadWriteMany<DataStream, unsigned long>(DataStream&, unsigned long const&)
Line
Count
Source
1066
20.0k
    {
1067
20.0k
        ::SerializeMany(s, args...);
1068
20.0k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, TransactionSerParams>, COutPoint, CScript, unsigned int>(ParamsStream<VectorWriter&, TransactionSerParams>&, COutPoint const&, CScript const&, unsigned int const&)
Line
Count
Source
1066
69.5k
    {
1067
69.5k
        ::SerializeMany(s, args...);
1068
69.5k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, TransactionSerParams>, transaction_identifier<false>, unsigned int>(ParamsStream<VectorWriter&, TransactionSerParams>&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1066
69.5k
    {
1067
69.5k
        ::SerializeMany(s, args...);
1068
69.5k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>>(ParamsStream<VectorWriter&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1066
240k
    {
1067
240k
        ::SerializeMany(s, args...);
1068
240k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, TransactionSerParams>, long, CScript>(ParamsStream<VectorWriter&, TransactionSerParams>&, long const&, CScript const&)
Line
Count
Source
1066
170k
    {
1067
170k
        ::SerializeMany(s, args...);
1068
170k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<HashWriter&, TransactionSerParams>, COutPoint, CScript, unsigned int>(ParamsStream<HashWriter&, TransactionSerParams>&, COutPoint const&, CScript const&, unsigned int const&)
Line
Count
Source
1066
2.10M
    {
1067
2.10M
        ::SerializeMany(s, args...);
1068
2.10M
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<HashWriter&, TransactionSerParams>, transaction_identifier<false>, unsigned int>(ParamsStream<HashWriter&, TransactionSerParams>&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1066
2.10M
    {
1067
2.10M
        ::SerializeMany(s, args...);
1068
2.10M
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<HashWriter&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>>(ParamsStream<HashWriter&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1066
5.94M
    {
1067
5.94M
        ::SerializeMany(s, args...);
1068
5.94M
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<HashWriter&, TransactionSerParams>, long, CScript>(ParamsStream<HashWriter&, TransactionSerParams>&, long const&, CScript const&)
Line
Count
Source
1066
3.83M
    {
1067
3.83M
        ::SerializeMany(s, args...);
1068
3.83M
    }
void ActionSerialize::SerReadWriteMany<DataStream, std::array<unsigned char, 4ul>, char [12], unsigned int, unsigned char [4]>(DataStream&, std::array<unsigned char, 4ul> const&, char const (&) [12], unsigned int const&, unsigned char const (&) [4])
Line
Count
Source
1066
2
    {
1067
2
        ::SerializeMany(s, args...);
1068
2
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, CAddress::SerParams>, CNetAddr, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr const&, Wrapper<CustomUintFormatter<2, true>, unsigned short const&> const&)
Line
Count
Source
1066
1
    {
1067
1
        ::SerializeMany(s, args...);
1068
1
    }
void ActionSerialize::SerReadWriteMany<DataStream, int>(DataStream&, int const&)
Line
Count
Source
1066
143k
    {
1067
143k
        ::SerializeMany(s, args...);
1068
143k
    }
void ActionSerialize::SerReadWriteMany<DataStream, bool>(DataStream&, bool const&)
Line
Count
Source
1066
1
    {
1067
1
        ::SerializeMany(s, args...);
1068
1
    }
void ActionSerialize::SerReadWriteMany<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
1066
1
    {
1067
1
        ::SerializeMany(s, args...);
1068
1
    }
void ActionSerialize::SerReadWriteMany<DataStream, char [16]>(DataStream&, char const (&) [16])
Line
Count
Source
1066
1
    {
1067
1
        ::SerializeMany(s, args...);
1068
1
    }
void ActionSerialize::SerReadWriteMany<DataStream, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const>>(DataStream&, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const> const&)
Line
Count
Source
1066
1
    {
1067
1
        ::SerializeMany(s, args...);
1068
1
    }
void ActionSerialize::SerReadWriteMany<DataStream, int, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [16], ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const>>(DataStream&, int const&, bool const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [16], ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const> const&)
Line
Count
Source
1066
1
    {
1067
1
        ::SerializeMany(s, args...);
1068
1
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>, ParamsWrapper<serialize_tests::BaseFormat, serialize_tests::Base const>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, ParamsWrapper<serialize_tests::BaseFormat, serialize_tests::Base const> const&)
Line
Count
Source
1066
2
    {
1067
2
        ::SerializeMany(s, args...);
1068
2
    }
void ActionSerialize::SerReadWriteMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&>, Wrapper<CustomUintFormatter<3, true>, unsigned int const&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> const&, Wrapper<CustomUintFormatter<3, true>, unsigned int const&> const&)
Line
Count
Source
1066
4.58k
    {
1067
4.58k
        ::SerializeMany(s, args...);
1068
4.58k
    }
void ActionSerialize::SerReadWriteMany<DataStream, unsigned char>(DataStream&, unsigned char const&)
Line
Count
Source
1066
18.0k
    {
1067
18.0k
        ::SerializeMany(s, args...);
1068
18.0k
    }
void ActionSerialize::SerReadWriteMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> const&)
Line
Count
Source
1066
443k
    {
1067
443k
        ::SerializeMany(s, args...);
1068
443k
    }
void ActionSerialize::SerReadWriteMany<DataStream, Wrapper<CustomUintFormatter<5, true>, unsigned long const&>, txindex::BlockTxPosition>(DataStream&, Wrapper<CustomUintFormatter<5, true>, unsigned long const&> const&, txindex::BlockTxPosition const&)
Line
Count
Source
1066
4.57k
    {
1067
4.57k
        ::SerializeMany(s, args...);
1068
4.57k
    }
void ActionSerialize::SerReadWriteMany<SizeComputer, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(SizeComputer&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1066
35.6k
    {
1067
35.6k
        ::SerializeMany(s, args...);
1068
35.6k
    }
void ActionSerialize::SerReadWriteMany<DataStream, FlatFilePos, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&>>(DataStream&, FlatFilePos const&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> const&)
Line
Count
Source
1066
46
    {
1067
46
        ::SerializeMany(s, args...);
1068
46
    }
void ActionSerialize::SerReadWriteMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int const&>, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)1>, int const&> const&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int const&> const&)
Line
Count
Source
1066
8.33k
    {
1067
8.33k
        ::SerializeMany(s, args...);
1068
8.33k
    }
void ActionSerialize::SerReadWriteMany<DataStream, std::vector<uint256, std::allocator<uint256>>>(DataStream&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
1066
25.7k
    {
1067
25.7k
        ::SerializeMany(s, args...);
1068
25.7k
    }
void ActionSerialize::SerReadWriteMany<SizeComputer, long, CScript>(SizeComputer&, long const&, CScript const&)
Line
Count
Source
1066
402k
    {
1067
402k
        ::SerializeMany(s, args...);
1068
402k
    }
void ActionSerialize::SerReadWriteMany<SizeComputer, prevector<36u, unsigned char, unsigned int, int>>(SizeComputer&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1066
402k
    {
1067
402k
        ::SerializeMany(s, args...);
1068
402k
    }
void ActionSerialize::SerReadWriteMany<DataStream, long, CScript>(DataStream&, long const&, CScript const&)
Line
Count
Source
1066
7.45k
    {
1067
7.45k
        ::SerializeMany(s, args...);
1068
7.45k
    }
void ActionSerialize::SerReadWriteMany<DataStream, prevector<36u, unsigned char, unsigned int, int>>(DataStream&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1066
10.0k
    {
1067
10.0k
        ::SerializeMany(s, args...);
1068
10.0k
    }
void ActionSerialize::SerReadWriteMany<SizeComputer, uint256>(SizeComputer&, uint256 const&)
Line
Count
Source
1066
5.96k
    {
1067
5.96k
        ::SerializeMany(s, args...);
1068
5.96k
    }
void ActionSerialize::SerReadWriteMany<DataStream, uint256>(DataStream&, uint256 const&)
Line
Count
Source
1066
267k
    {
1067
267k
        ::SerializeMany(s, args...);
1068
267k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, CNetAddr::SerParams>, CNetAddr, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(ParamsStream<VectorWriter&, CNetAddr::SerParams>&, CNetAddr const&, Wrapper<CustomUintFormatter<2, true>, unsigned short const&> const&)
Line
Count
Source
1066
3.48k
    {
1067
3.48k
        ::SerializeMany(s, args...);
1068
3.48k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, unsigned int>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, unsigned int const&)
Line
Count
Source
1066
50.3k
    {
1067
50.3k
        ::SerializeMany(s, args...);
1068
50.3k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> const&)
Line
Count
Source
1066
50.3k
    {
1067
50.3k
        ::SerializeMany(s, args...);
1068
50.3k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&> const&)
Line
Count
Source
1066
50.3k
    {
1067
50.3k
        ::SerializeMany(s, args...);
1068
50.3k
    }
Unexecuted instantiation: void ActionSerialize::SerReadWriteMany<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&> const&)
void ActionSerialize::SerReadWriteMany<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService const>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService const> const&)
Line
Count
Source
1066
50.3k
    {
1067
50.3k
        ::SerializeMany(s, args...);
1068
50.3k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr const&, Wrapper<CustomUintFormatter<2, true>, unsigned short const&> const&)
Line
Count
Source
1066
50.3k
    {
1067
50.3k
        ::SerializeMany(s, args...);
1068
50.3k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, CAddress, CNetAddr, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>, int>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CAddress const&, CNetAddr const&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> const&, int const&)
Line
Count
Source
1066
50.3k
    {
1067
50.3k
        ::SerializeMany(s, args...);
1068
50.3k
    }
void ActionSerialize::SerReadWriteMany<SizeComputer, CBlockHeader, unsigned long, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>>(SizeComputer&, CBlockHeader const&, unsigned long const&, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&> const&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
1066
35.6k
    {
1067
35.6k
        ::SerializeMany(s, args...);
1068
35.6k
    }
void ActionSerialize::SerReadWriteMany<SizeComputer, Wrapper<CompactSizeFormatter<true>, unsigned short const&>, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>>(SizeComputer&, Wrapper<CompactSizeFormatter<true>, unsigned short const&> const&, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>> const&)
Line
Count
Source
1066
35.7k
    {
1067
35.7k
        ::SerializeMany(s, args...);
1068
35.7k
    }
void ActionSerialize::SerReadWriteMany<DataStream, uint256, uint256, FlatFilePos>(DataStream&, uint256 const&, uint256 const&, FlatFilePos const&)
Line
Count
Source
1066
8.11k
    {
1067
8.11k
        ::SerializeMany(s, args...);
1068
8.11k
    }
void ActionSerialize::SerReadWriteMany<DataStream, long>(DataStream&, long const&)
Line
Count
Source
1066
25.3k
    {
1067
25.3k
        ::SerializeMany(s, args...);
1068
25.3k
    }
void ActionSerialize::SerReadWriteMany<DataStream, CDiskTxPos>(DataStream&, CDiskTxPos const&)
Line
Count
Source
1066
44
    {
1067
44
        ::SerializeMany(s, args...);
1068
44
    }
void ActionSerialize::SerReadWriteMany<HashWriter, transaction_identifier<false>, unsigned int>(HashWriter&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1066
21.5M
    {
1067
21.5M
        ::SerializeMany(s, args...);
1068
21.5M
    }
void ActionSerialize::SerReadWriteMany<HashWriter, long, CScript>(HashWriter&, long const&, CScript const&)
Line
Count
Source
1066
14.4M
    {
1067
14.4M
        ::SerializeMany(s, args...);
1068
14.4M
    }
void ActionSerialize::SerReadWriteMany<HashWriter, prevector<36u, unsigned char, unsigned int, int>>(HashWriter&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1066
15.4M
    {
1067
15.4M
        ::SerializeMany(s, args...);
1068
15.4M
    }
void ActionSerialize::SerReadWriteMany<DataStream, transaction_identifier<false>, unsigned int>(DataStream&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1066
6.20k
    {
1067
6.20k
        ::SerializeMany(s, args...);
1068
6.20k
    }
void ActionSerialize::SerReadWriteMany<VectorWriter, std::array<unsigned char, 4ul>, char [12], unsigned int, unsigned char [4]>(VectorWriter&, std::array<unsigned char, 4ul> const&, char const (&) [12], unsigned int const&, unsigned char const (&) [4])
Line
Count
Source
1066
136k
    {
1067
136k
        ::SerializeMany(s, args...);
1068
136k
    }
void ActionSerialize::SerReadWriteMany<VectorWriter, CBlockHeader, unsigned long, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>>(VectorWriter&, CBlockHeader const&, unsigned long const&, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>> const&> const&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>> const&)
Line
Count
Source
1066
18.8k
    {
1067
18.8k
        ::SerializeMany(s, args...);
1068
18.8k
    }
void ActionSerialize::SerReadWriteMany<VectorWriter, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(VectorWriter&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1066
18.8k
    {
1067
18.8k
        ::SerializeMany(s, args...);
1068
18.8k
    }
void ActionSerialize::SerReadWriteMany<VectorWriter, Wrapper<CompactSizeFormatter<true>, unsigned short const&>, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>>(VectorWriter&, Wrapper<CompactSizeFormatter<true>, unsigned short const&> const&, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>> const&)
Line
Count
Source
1066
18.8k
    {
1067
18.8k
        ::SerializeMany(s, args...);
1068
18.8k
    }
void ActionSerialize::SerReadWriteMany<VectorWriter, unsigned int, uint256>(VectorWriter&, unsigned int const&, uint256 const&)
Line
Count
Source
1066
84.8k
    {
1067
84.8k
        ::SerializeMany(s, args...);
1068
84.8k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, TransactionSerParams>, CBlockHeader, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<VectorWriter&, TransactionSerParams>&, CBlockHeader const&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
1066
35.0k
    {
1067
35.0k
        ::SerializeMany(s, args...);
1068
35.0k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, TransactionSerParams>, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(ParamsStream<VectorWriter&, TransactionSerParams>&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1066
35.0k
    {
1067
35.0k
        ::SerializeMany(s, args...);
1068
35.0k
    }
void ActionSerialize::SerReadWriteMany<VectorWriter, CBlockHeader, CPartialMerkleTree>(VectorWriter&, CBlockHeader const&, CPartialMerkleTree const&)
Line
Count
Source
1066
4
    {
1067
4
        ::SerializeMany(s, args...);
1068
4
    }
void ActionSerialize::SerReadWriteMany<VectorWriter, unsigned int, std::vector<uint256, std::allocator<uint256>>>(VectorWriter&, unsigned int const&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
1066
4
    {
1067
4
        ::SerializeMany(s, args...);
1068
4
    }
void ActionSerialize::SerReadWriteMany<VectorWriter, std::vector<unsigned char, std::allocator<unsigned char>>>(VectorWriter&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
1066
4
    {
1067
4
        ::SerializeMany(s, args...);
1068
4
    }
void ActionSerialize::SerReadWriteMany<VectorWriter, int>(VectorWriter&, int const&)
Line
Count
Source
1066
3.01k
    {
1067
3.01k
        ::SerializeMany(s, args...);
1068
3.01k
    }
void ActionSerialize::SerReadWriteMany<VectorWriter, std::vector<uint256, std::allocator<uint256>>>(VectorWriter&, std::vector<uint256, std::allocator<uint256>> const&)
Line
Count
Source
1066
3.01k
    {
1067
3.01k
        ::SerializeMany(s, args...);
1068
3.01k
    }
void ActionSerialize::SerReadWriteMany<VectorWriter, uint256, ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>>>(VectorWriter&, uint256 const&, ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>> const&)
Line
Count
Source
1066
590
    {
1067
590
        ::SerializeMany(s, args...);
1068
590
    }
void ActionSerialize::SerReadWriteMany<VectorWriter, uint256, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&>>(VectorWriter&, uint256 const&, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>> const&> const&)
Line
Count
Source
1066
577
    {
1067
577
        ::SerializeMany(s, args...);
1068
577
    }
Unexecuted instantiation: void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, CAddress::SerParams>, unsigned int>(ParamsStream<VectorWriter&, CAddress::SerParams>&, unsigned int const&)
void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>> const&> const&)
Line
Count
Source
1066
18.9k
    {
1067
18.9k
        ::SerializeMany(s, args...);
1068
18.9k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&> const&)
Line
Count
Source
1066
33
    {
1067
33
        ::SerializeMany(s, args...);
1068
33
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags const&> const&)
Line
Count
Source
1066
18.9k
    {
1067
18.9k
        ::SerializeMany(s, args...);
1068
18.9k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<VectorWriter&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService const>>(ParamsStream<VectorWriter&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService const> const&)
Line
Count
Source
1066
18.9k
    {
1067
18.9k
        ::SerializeMany(s, args...);
1068
18.9k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr, Wrapper<CustomUintFormatter<2, true>, unsigned short const&>>(ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr const&, Wrapper<CustomUintFormatter<2, true>, unsigned short const&> const&)
Line
Count
Source
1066
18.9k
    {
1067
18.9k
        ::SerializeMany(s, args...);
1068
18.9k
    }
void ActionSerialize::SerReadWriteMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long const&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long const&> const&)
Line
Count
Source
1066
3.44k
    {
1067
3.44k
        ::SerializeMany(s, args...);
1068
3.44k
    }
void ActionSerialize::SerReadWriteMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)1>, int&> const&)
Line
Count
Source
1066
117k
    {
1067
117k
        ::SerializeMany(s, args...);
1068
117k
    }
void ActionSerialize::SerReadWriteMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int const&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)1>, int const&> const&)
Line
Count
Source
1066
217k
    {
1067
217k
        ::SerializeMany(s, args...);
1068
217k
    }
void ActionSerialize::SerReadWriteMany<DataStream, unsigned int>(DataStream&, unsigned int const&)
Line
Count
Source
1066
352k
    {
1067
352k
        ::SerializeMany(s, args...);
1068
352k
    }
void ActionSerialize::SerReadWriteMany<SizeComputer, std::vector<CTxUndo, std::allocator<CTxUndo>>>(SizeComputer&, std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
1066
100k
    {
1067
100k
        ::SerializeMany(s, args...);
1068
100k
    }
void ActionSerialize::SerReadWriteMany<SizeComputer, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>>(SizeComputer&, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&> const&)
Line
Count
Source
1066
45.0k
    {
1067
45.0k
        ::SerializeMany(s, args...);
1068
45.0k
    }
void ActionSerialize::SerReadWriteMany<SizeComputer, Wrapper<AmountCompression, long const&>, Wrapper<ScriptCompression, CScript const&>>(SizeComputer&, Wrapper<AmountCompression, long const&> const&, Wrapper<ScriptCompression, CScript const&> const&)
Line
Count
Source
1066
69.5k
    {
1067
69.5k
        ::SerializeMany(s, args...);
1068
69.5k
    }
void ActionSerialize::SerReadWriteMany<HashWriter, std::vector<CTxUndo, std::allocator<CTxUndo>>>(HashWriter&, std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
1066
100k
    {
1067
100k
        ::SerializeMany(s, args...);
1068
100k
    }
void ActionSerialize::SerReadWriteMany<HashWriter, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>>(HashWriter&, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&> const&)
Line
Count
Source
1066
45.0k
    {
1067
45.0k
        ::SerializeMany(s, args...);
1068
45.0k
    }
void ActionSerialize::SerReadWriteMany<HashWriter, Wrapper<AmountCompression, long const&>, Wrapper<ScriptCompression, CScript const&>>(HashWriter&, Wrapper<AmountCompression, long const&> const&, Wrapper<ScriptCompression, CScript const&> const&)
Line
Count
Source
1066
69.5k
    {
1067
69.5k
        ::SerializeMany(s, args...);
1068
69.5k
    }
void ActionSerialize::SerReadWriteMany<BufferedWriter<AutoFile>, std::vector<CTxUndo, std::allocator<CTxUndo>>>(BufferedWriter<AutoFile>&, std::vector<CTxUndo, std::allocator<CTxUndo>> const&)
Line
Count
Source
1066
100k
    {
1067
100k
        ::SerializeMany(s, args...);
1068
100k
    }
void ActionSerialize::SerReadWriteMany<BufferedWriter<AutoFile>, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&>>(BufferedWriter<AutoFile>&, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>> const&> const&)
Line
Count
Source
1066
45.0k
    {
1067
45.0k
        ::SerializeMany(s, args...);
1068
45.0k
    }
void ActionSerialize::SerReadWriteMany<BufferedWriter<AutoFile>, Wrapper<AmountCompression, long const&>, Wrapper<ScriptCompression, CScript const&>>(BufferedWriter<AutoFile>&, Wrapper<AmountCompression, long const&> const&, Wrapper<ScriptCompression, CScript const&> const&)
Line
Count
Source
1066
69.5k
    {
1067
69.5k
        ::SerializeMany(s, args...);
1068
69.5k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, CBlockHeader, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, CBlockHeader const&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
1066
102k
    {
1067
102k
        ::SerializeMany(s, args...);
1068
102k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1066
102k
    {
1067
102k
        ::SerializeMany(s, args...);
1068
102k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, COutPoint, CScript, unsigned int>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, COutPoint const&, CScript const&, unsigned int const&)
Line
Count
Source
1066
185k
    {
1067
185k
        ::SerializeMany(s, args...);
1068
185k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, transaction_identifier<false>, unsigned int>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1066
185k
    {
1067
185k
        ::SerializeMany(s, args...);
1068
185k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1066
567k
    {
1067
567k
        ::SerializeMany(s, args...);
1068
567k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>, long, CScript>(ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>&, long const&, CScript const&)
Line
Count
Source
1066
381k
    {
1067
381k
        ::SerializeMany(s, args...);
1068
381k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<AutoFile&, TransactionSerParams>, COutPoint, CScript, unsigned int>(ParamsStream<AutoFile&, TransactionSerParams>&, COutPoint const&, CScript const&, unsigned int const&)
Line
Count
Source
1066
2.38k
    {
1067
2.38k
        ::SerializeMany(s, args...);
1068
2.38k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<AutoFile&, TransactionSerParams>, transaction_identifier<false>, unsigned int>(ParamsStream<AutoFile&, TransactionSerParams>&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1066
2.38k
    {
1067
2.38k
        ::SerializeMany(s, args...);
1068
2.38k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<AutoFile&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>>(ParamsStream<AutoFile&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1066
4.25k
    {
1067
4.25k
        ::SerializeMany(s, args...);
1068
4.25k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<AutoFile&, TransactionSerParams>, long, CScript>(ParamsStream<AutoFile&, TransactionSerParams>&, long const&, CScript const&)
Line
Count
Source
1066
1.87k
    {
1067
1.87k
        ::SerializeMany(s, args...);
1068
1.87k
    }
void ActionSerialize::SerReadWriteMany<DataStream, unsigned int, unsigned int, CTxOut>(DataStream&, unsigned int const&, unsigned int const&, CTxOut const&)
Line
Count
Source
1066
2
    {
1067
2
        ::SerializeMany(s, args...);
1068
2
    }
void ActionSerialize::SerReadWriteMany<AutoFile, Wrapper<AmountCompression, long const&>, Wrapper<ScriptCompression, CScript const&>>(AutoFile&, Wrapper<AmountCompression, long const&> const&, Wrapper<ScriptCompression, CScript const&> const&)
Line
Count
Source
1066
6.58k
    {
1067
6.58k
        ::SerializeMany(s, args...);
1068
6.58k
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, TransactionSerParams>, CBlockHeader, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>>(ParamsStream<DataStream&, TransactionSerParams>&, CBlockHeader const&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&)
Line
Count
Source
1066
41
    {
1067
41
        ::SerializeMany(s, args...);
1068
41
    }
void ActionSerialize::SerReadWriteMany<ParamsStream<DataStream&, TransactionSerParams>, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(ParamsStream<DataStream&, TransactionSerParams>&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1066
42
    {
1067
42
        ::SerializeMany(s, args...);
1068
42
    }
void ActionSerialize::SerReadWriteMany<DataStream, unsigned char, transaction_identifier<false>, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(DataStream&, unsigned char const&, transaction_identifier<false> const&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> const&)
Line
Count
Source
1066
5.62M
    {
1067
5.62M
        ::SerializeMany(s, args...);
1068
5.62M
    }
void ActionSerialize::SerReadWriteMany<DataStream, Wrapper<AmountCompression, long const&>, Wrapper<ScriptCompression, CScript const&>>(DataStream&, Wrapper<AmountCompression, long const&> const&, Wrapper<ScriptCompression, CScript const&> const&)
Line
Count
Source
1066
289k
    {
1067
289k
        ::SerializeMany(s, args...);
1068
289k
    }
void ActionSerialize::SerReadWriteMany<HashWriter, int, uint256, uint256, unsigned int, unsigned int, unsigned int>(HashWriter&, int const&, uint256 const&, uint256 const&, unsigned int const&, unsigned int const&, unsigned int const&)
Line
Count
Source
1066
18.5M
    {
1067
18.5M
        ::SerializeMany(s, args...);
1068
18.5M
    }
void ActionSerialize::SerReadWriteMany<DataStream, int, long>(DataStream&, int const&, long const&)
Line
Count
Source
1066
60
    {
1067
60
        ::SerializeMany(s, args...);
1068
60
    }
void ActionSerialize::SerReadWriteMany<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CKeyID>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, CKeyID const&)
Line
Count
Source
1066
60
    {
1067
60
        ::SerializeMany(s, args...);
1068
60
    }
Unexecuted instantiation: void ActionSerialize::SerReadWriteMany<DataStream, KeyOriginInfo>(DataStream&, KeyOriginInfo const&)
Unexecuted instantiation: void ActionSerialize::SerReadWriteMany<DataStream, std::array<unsigned char, 4ul>, std::vector<unsigned int, std::allocator<unsigned int>>>(DataStream&, std::array<unsigned char, 4ul> const&, std::vector<unsigned int, std::allocator<unsigned int>> const&)
void ActionSerialize::SerReadWriteMany<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>, std::vector<unsigned char, std::allocator<unsigned char>>, unsigned int, unsigned int, std::vector<unsigned char, std::allocator<unsigned char>>>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&, unsigned int const&, unsigned int const&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
1066
45
    {
1067
45
        ::SerializeMany(s, args...);
1068
45
    }
void ActionSerialize::SerReadWriteMany<SpanWriter, transaction_identifier<false>, unsigned int>(SpanWriter&, transaction_identifier<false> const&, unsigned int const&)
Line
Count
Source
1066
59
    {
1067
59
        ::SerializeMany(s, args...);
1068
59
    }
1069
1070
    template<typename Stream, typename Type, typename Fn>
1071
    static void SerRead(Stream& s, Type&&, Fn&&)
1072
63.4k
    {
1073
63.4k
    }
void ActionSerialize::SerRead<ParamsStream<DataStream&, CAddress::SerParams>, CAddress const&, void CAddress::SerializationOps<ParamsStream<DataStream&, CAddress::SerParams>, CAddress const, ActionSerialize>(CAddress const&, ParamsStream<DataStream&, CAddress::SerParams>&, ActionSerialize)::'lambda'(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress&)>(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress const&&, ActionSerialize&&)
Line
Count
Source
1072
18
    {
1073
18
    }
void ActionSerialize::SerRead<DataStream, CPartialMerkleTree const&, void CPartialMerkleTree::SerializationOps<DataStream, CPartialMerkleTree const, ActionSerialize>(CPartialMerkleTree const&, DataStream&, ActionSerialize)::'lambda'(DataStream&, CPartialMerkleTree&)>(DataStream&, CPartialMerkleTree const&&, ActionSerialize&&)
Line
Count
Source
1072
182
    {
1073
182
    }
void ActionSerialize::SerRead<DataStream, CPartialMerkleTree const&, void CPartialMerkleTree::SerializationOps<DataStream, CPartialMerkleTree const, ActionSerialize>(CPartialMerkleTree const&, DataStream&, ActionSerialize)::'lambda0'(DataStream&, CPartialMerkleTree&)>(DataStream&, CPartialMerkleTree const&&, ActionSerialize&&)
Line
Count
Source
1072
182
    {
1073
182
    }
Unexecuted instantiation: void ActionSerialize::SerRead<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>, serialize_tests::Derived const&, void serialize_tests::Derived::SerializationOps<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>, serialize_tests::Derived const, ActionSerialize>(serialize_tests::Derived const&, ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, ActionSerialize)::'lambda'(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::Derived&)>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::Derived const&&, ActionSerialize&&)
void ActionSerialize::SerRead<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, CAddress const&, void CAddress::SerializationOps<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, CAddress const, ActionSerialize>(CAddress const&, ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, ActionSerialize)::'lambda'(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CAddress&)>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CAddress const&&, ActionSerialize&&)
Line
Count
Source
1072
50.3k
    {
1073
50.3k
    }
coinstatsindex.cpp:void ActionSerialize::SerRead<DataStream, (anonymous namespace)::DBVal const&, void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal const, ActionSerialize>((anonymous namespace)::DBVal const&, DataStream&, ActionSerialize)::'lambda'(DataStream&, (anonymous namespace)::DBVal&)>(DataStream&, (anonymous namespace)::DBVal const&&, ActionSerialize&&)
Line
Count
Source
1072
4.22k
    {
1073
4.22k
    }
coinstatsindex.cpp:void ActionSerialize::SerRead<DataStream, (anonymous namespace)::DBVal const&, void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal const, ActionSerialize>((anonymous namespace)::DBVal const&, DataStream&, ActionSerialize)::'lambda0'(DataStream&, (anonymous namespace)::DBVal&)>(DataStream&, (anonymous namespace)::DBVal const&&, ActionSerialize&&)
Line
Count
Source
1072
4.22k
    {
1073
4.22k
    }
coinstatsindex.cpp:void ActionSerialize::SerRead<DataStream, (anonymous namespace)::DBVal const&, void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal const, ActionSerialize>((anonymous namespace)::DBVal const&, DataStream&, ActionSerialize)::'lambda1'(DataStream&, (anonymous namespace)::DBVal&)>(DataStream&, (anonymous namespace)::DBVal const&&, ActionSerialize&&)
Line
Count
Source
1072
4.22k
    {
1073
4.22k
    }
void ActionSerialize::SerRead<VectorWriter, CPartialMerkleTree const&, void CPartialMerkleTree::SerializationOps<VectorWriter, CPartialMerkleTree const, ActionSerialize>(CPartialMerkleTree const&, VectorWriter&, ActionSerialize)::'lambda'(VectorWriter&, CPartialMerkleTree&)>(VectorWriter&, CPartialMerkleTree const&&, ActionSerialize&&)
Line
Count
Source
1072
4
    {
1073
4
    }
void ActionSerialize::SerRead<VectorWriter, CPartialMerkleTree const&, void CPartialMerkleTree::SerializationOps<VectorWriter, CPartialMerkleTree const, ActionSerialize>(CPartialMerkleTree const&, VectorWriter&, ActionSerialize)::'lambda0'(VectorWriter&, CPartialMerkleTree&)>(VectorWriter&, CPartialMerkleTree const&&, ActionSerialize&&)
Line
Count
Source
1072
4
    {
1073
4
    }
void ActionSerialize::SerRead<ParamsStream<VectorWriter&, CAddress::SerParams>, CAddress const&, void CAddress::SerializationOps<ParamsStream<VectorWriter&, CAddress::SerParams>, CAddress const, ActionSerialize>(CAddress const&, ParamsStream<VectorWriter&, CAddress::SerParams>&, ActionSerialize)::'lambda'(ParamsStream<VectorWriter&, CAddress::SerParams>&, CAddress&)>(ParamsStream<VectorWriter&, CAddress::SerParams>&, CAddress const&&, ActionSerialize&&)
Line
Count
Source
1072
33
    {
1073
33
    }
1074
1075
    template<typename Stream, typename Type, typename Fn>
1076
    static void SerWrite(Stream& s, Type&& obj, Fn&& fn)
1077
63.2k
    {
1078
63.2k
        fn(s, std::forward<Type>(obj));
1079
63.2k
    }
void ActionSerialize::SerWrite<ParamsStream<DataStream&, CAddress::SerParams>, CAddress const&, void CAddress::SerializationOps<ParamsStream<DataStream&, CAddress::SerParams>, CAddress const, ActionSerialize>(CAddress const&, ParamsStream<DataStream&, CAddress::SerParams>&, ActionSerialize)::'lambda'(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress const&)>(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress const&&, ActionSerialize&&)
Line
Count
Source
1077
18
    {
1078
18
        fn(s, std::forward<Type>(obj));
1079
18
    }
void ActionSerialize::SerWrite<DataStream, CPartialMerkleTree const&, void CPartialMerkleTree::SerializationOps<DataStream, CPartialMerkleTree const, ActionSerialize>(CPartialMerkleTree const&, DataStream&, ActionSerialize)::'lambda'(DataStream&, CPartialMerkleTree const&)>(DataStream&, CPartialMerkleTree const&&, ActionSerialize&&)
Line
Count
Source
1077
182
    {
1078
182
        fn(s, std::forward<Type>(obj));
1079
182
    }
void ActionSerialize::SerWrite<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, CAddress const&, void CAddress::SerializationOps<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>, CAddress const, ActionSerialize>(CAddress const&, ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, ActionSerialize)::'lambda'(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CAddress const&)>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CAddress const&&, ActionSerialize&&)
Line
Count
Source
1077
50.3k
    {
1078
50.3k
        fn(s, std::forward<Type>(obj));
1079
50.3k
    }
coinstatsindex.cpp:void ActionSerialize::SerWrite<DataStream, (anonymous namespace)::DBVal const&, void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal const, ActionSerialize>((anonymous namespace)::DBVal const&, DataStream&, ActionSerialize)::'lambda'(DataStream&, (anonymous namespace)::DBVal const&)>(DataStream&, (anonymous namespace)::DBVal const&&, ActionSerialize&&)
Line
Count
Source
1077
4.22k
    {
1078
4.22k
        fn(s, std::forward<Type>(obj));
1079
4.22k
    }
coinstatsindex.cpp:void ActionSerialize::SerWrite<DataStream, (anonymous namespace)::DBVal const&, void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal const, ActionSerialize>((anonymous namespace)::DBVal const&, DataStream&, ActionSerialize)::'lambda0'(DataStream&, (anonymous namespace)::DBVal const&)>(DataStream&, (anonymous namespace)::DBVal const&&, ActionSerialize&&)
Line
Count
Source
1077
4.22k
    {
1078
4.22k
        fn(s, std::forward<Type>(obj));
1079
4.22k
    }
coinstatsindex.cpp:void ActionSerialize::SerWrite<DataStream, (anonymous namespace)::DBVal const&, void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal const, ActionSerialize>((anonymous namespace)::DBVal const&, DataStream&, ActionSerialize)::'lambda1'(DataStream&, (anonymous namespace)::DBVal const&)>(DataStream&, (anonymous namespace)::DBVal const&&, ActionSerialize&&)
Line
Count
Source
1077
4.22k
    {
1078
4.22k
        fn(s, std::forward<Type>(obj));
1079
4.22k
    }
void ActionSerialize::SerWrite<VectorWriter, CPartialMerkleTree const&, void CPartialMerkleTree::SerializationOps<VectorWriter, CPartialMerkleTree const, ActionSerialize>(CPartialMerkleTree const&, VectorWriter&, ActionSerialize)::'lambda'(VectorWriter&, CPartialMerkleTree const&)>(VectorWriter&, CPartialMerkleTree const&&, ActionSerialize&&)
Line
Count
Source
1077
4
    {
1078
4
        fn(s, std::forward<Type>(obj));
1079
4
    }
void ActionSerialize::SerWrite<ParamsStream<VectorWriter&, CAddress::SerParams>, CAddress const&, void CAddress::SerializationOps<ParamsStream<VectorWriter&, CAddress::SerParams>, CAddress const, ActionSerialize>(CAddress const&, ParamsStream<VectorWriter&, CAddress::SerParams>&, ActionSerialize)::'lambda'(ParamsStream<VectorWriter&, CAddress::SerParams>&, CAddress const&)>(ParamsStream<VectorWriter&, CAddress::SerParams>&, CAddress const&&, ActionSerialize&&)
Line
Count
Source
1077
33
    {
1078
33
        fn(s, std::forward<Type>(obj));
1079
33
    }
1080
};
1081
struct ActionUnserialize {
1082
0
    static constexpr bool ForRead() { return true; }
1083
1084
    template<typename Stream, typename... Args>
1085
    static void SerReadWriteMany(Stream& s, Args&&... args)
1086
7.17M
    {
1087
7.17M
        ::UnserializeMany(s, args...);
1088
7.17M
    }
void ActionUnserialize::SerReadWriteMany<DataStream, CBlockHeader&, unsigned long&, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>>&>, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&>(DataStream&, CBlockHeader&, unsigned long&, Wrapper<VectorFormatter<CustomUintFormatter<6, false>>, std::vector<unsigned long, std::allocator<unsigned long>>&>&&, std::vector<PrefilledTransaction, std::allocator<PrefilledTransaction>>&)
Line
Count
Source
1086
21.6k
    {
1087
21.6k
        ::UnserializeMany(s, args...);
1088
21.6k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(DataStream&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1086
476k
    {
1087
476k
        ::UnserializeMany(s, args...);
1088
476k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, Wrapper<CompactSizeFormatter<true>, unsigned short&>, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>>>(DataStream&, Wrapper<CompactSizeFormatter<true>, unsigned short&>&&, ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>>&&)
Line
Count
Source
1086
21.6k
    {
1087
21.6k
        ::UnserializeMany(s, args...);
1088
21.6k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, TransactionSerParams>, COutPoint&, CScript&, unsigned int&>(ParamsStream<DataStream&, TransactionSerParams>&, COutPoint&, CScript&, unsigned int&)
Line
Count
Source
1086
137k
    {
1087
137k
        ::UnserializeMany(s, args...);
1088
137k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, TransactionSerParams>, transaction_identifier<false>&, unsigned int&>(ParamsStream<DataStream&, TransactionSerParams>&, transaction_identifier<false>&, unsigned int&)
Line
Count
Source
1086
137k
    {
1087
137k
        ::UnserializeMany(s, args...);
1088
137k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>&>(ParamsStream<DataStream&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
1086
426k
    {
1087
426k
        ::UnserializeMany(s, args...);
1088
426k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, TransactionSerParams>, long&, CScript&>(ParamsStream<DataStream&, TransactionSerParams>&, long&, CScript&)
Line
Count
Source
1086
289k
    {
1087
289k
        ::UnserializeMany(s, args...);
1088
289k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, uint256&, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>>&>>(DataStream&, uint256&, Wrapper<VectorFormatter<DifferenceFormatter>, std::vector<unsigned short, std::allocator<unsigned short>>&>&&)
Line
Count
Source
1086
597
    {
1087
597
        ::UnserializeMany(s, args...);
1088
597
    }
void ActionUnserialize::SerReadWriteMany<DataStream, COutPoint&, CScript&, unsigned int&>(DataStream&, COutPoint&, CScript&, unsigned int&)
Line
Count
Source
1086
4.79k
    {
1087
4.79k
        ::UnserializeMany(s, args...);
1088
4.79k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, transaction_identifier<false>&, unsigned int&>(DataStream&, transaction_identifier<false>&, unsigned int&)
Line
Count
Source
1086
4.79k
    {
1087
4.79k
        ::UnserializeMany(s, args...);
1088
4.79k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, prevector<36u, unsigned char, unsigned int, int>&>(DataStream&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
1086
9.76k
    {
1087
9.76k
        ::UnserializeMany(s, args...);
1088
9.76k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, long&, CScript&>(DataStream&, long&, CScript&)
Line
Count
Source
1086
4.78k
    {
1087
4.78k
        ::UnserializeMany(s, args...);
1088
4.78k
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, COutPoint&, CScript&, unsigned int&>(SpanReader&, COutPoint&, CScript&, unsigned int&)
Line
Count
Source
1086
1
    {
1087
1
        ::UnserializeMany(s, args...);
1088
1
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, transaction_identifier<false>&, unsigned int&>(SpanReader&, transaction_identifier<false>&, unsigned int&)
Line
Count
Source
1086
1
    {
1087
1
        ::UnserializeMany(s, args...);
1088
1
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, prevector<36u, unsigned char, unsigned int, int>&>(SpanReader&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
1086
8.14k
    {
1087
8.14k
        ::UnserializeMany(s, args...);
1088
8.14k
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, long&, CScript&>(SpanReader&, long&, CScript&)
Line
Count
Source
1086
4.78k
    {
1087
4.78k
        ::UnserializeMany(s, args...);
1088
4.78k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, TransactionSerParams>, CBlockHeader&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(ParamsStream<DataStream&, TransactionSerParams>&, CBlockHeader&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
1086
34.2k
    {
1087
34.2k
        ::UnserializeMany(s, args...);
1088
34.2k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, TransactionSerParams>, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(ParamsStream<DataStream&, TransactionSerParams>&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1086
34.2k
    {
1087
34.2k
        ::UnserializeMany(s, args...);
1088
34.2k
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, Wrapper<AmountCompression, long&>, Wrapper<ScriptCompression, CScript&>>(SpanReader&, Wrapper<AmountCompression, long&>&&, Wrapper<ScriptCompression, CScript&>&&)
Line
Count
Source
1086
89.6k
    {
1087
89.6k
        ::UnserializeMany(s, args...);
1088
89.6k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, Num3072&>(DataStream&, Num3072&)
Line
Count
Source
1086
4
    {
1087
4
        ::UnserializeMany(s, args...);
1088
4
    }
void ActionUnserialize::SerReadWriteMany<DataStream, unsigned long&>(DataStream&, unsigned long&)
Line
Count
Source
1086
434
    {
1087
434
        ::UnserializeMany(s, args...);
1088
434
    }
Unexecuted instantiation: void ActionUnserialize::SerReadWriteMany<ParamsStream<SpanReader&, CAddress::SerParams>, unsigned int&>(ParamsStream<SpanReader&, CAddress::SerParams>&, unsigned int&)
void ActionUnserialize::SerReadWriteMany<ParamsStream<SpanReader&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>>(ParamsStream<SpanReader&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&&)
Line
Count
Source
1086
7
    {
1087
7
        ::UnserializeMany(s, args...);
1088
7
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<SpanReader&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(ParamsStream<SpanReader&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&>&&)
Line
Count
Source
1086
3
    {
1087
3
        ::UnserializeMany(s, args...);
1088
3
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<SpanReader&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>>(ParamsStream<SpanReader&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&&)
Line
Count
Source
1086
4
    {
1087
4
        ::UnserializeMany(s, args...);
1088
4
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<SpanReader&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>>(ParamsStream<SpanReader&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService>&&)
Line
Count
Source
1086
7
    {
1087
7
        ::UnserializeMany(s, args...);
1088
7
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>>(ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&&)
Line
Count
Source
1086
7
    {
1087
7
        ::UnserializeMany(s, args...);
1088
7
    }
void ActionUnserialize::SerReadWriteMany<DataStream, unsigned int&, std::vector<uint256, std::allocator<uint256>>&>(DataStream&, unsigned int&, std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
1086
168
    {
1087
168
        ::UnserializeMany(s, args...);
1088
168
    }
void ActionUnserialize::SerReadWriteMany<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>&>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
1086
168
    {
1087
168
        ::UnserializeMany(s, args...);
1088
168
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<SpanReader&, TransactionSerParams>, COutPoint&, CScript&, unsigned int&>(ParamsStream<SpanReader&, TransactionSerParams>&, COutPoint&, CScript&, unsigned int&)
Line
Count
Source
1086
332k
    {
1087
332k
        ::UnserializeMany(s, args...);
1088
332k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<SpanReader&, TransactionSerParams>, transaction_identifier<false>&, unsigned int&>(ParamsStream<SpanReader&, TransactionSerParams>&, transaction_identifier<false>&, unsigned int&)
Line
Count
Source
1086
332k
    {
1087
332k
        ::UnserializeMany(s, args...);
1088
332k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<SpanReader&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>&>(ParamsStream<SpanReader&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
1086
853k
    {
1087
853k
        ::UnserializeMany(s, args...);
1088
853k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<SpanReader&, TransactionSerParams>, long&, CScript&>(ParamsStream<SpanReader&, TransactionSerParams>&, long&, CScript&)
Line
Count
Source
1086
521k
    {
1087
521k
        ::UnserializeMany(s, args...);
1088
521k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, int&, bool&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char (&) [16], ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>>(DataStream&, int&, bool&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char (&) [16], ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>&&)
Line
Count
Source
1086
1
    {
1087
1
        ::UnserializeMany(s, args...);
1088
1
    }
void ActionUnserialize::SerReadWriteMany<DataStream, int&>(DataStream&, int&)
Line
Count
Source
1086
157k
    {
1087
157k
        ::UnserializeMany(s, args...);
1088
157k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, bool&>(DataStream&, bool&)
Line
Count
Source
1086
279
    {
1087
279
        ::UnserializeMany(s, args...);
1088
279
    }
void ActionUnserialize::SerReadWriteMany<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
1086
2
    {
1087
2
        ::UnserializeMany(s, args...);
1088
2
    }
void ActionUnserialize::SerReadWriteMany<DataStream, char (&) [16]>(DataStream&, char (&) [16])
Line
Count
Source
1086
2
    {
1087
2
        ::UnserializeMany(s, args...);
1088
2
    }
void ActionUnserialize::SerReadWriteMany<DataStream, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>>(DataStream&, ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>&&)
Line
Count
Source
1086
2
    {
1087
2
        ::UnserializeMany(s, args...);
1088
2
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, unsigned char&>(SpanReader&, unsigned char&)
Line
Count
Source
1086
352
    {
1087
352
        ::UnserializeMany(s, args...);
1088
352
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, Wrapper<CustomUintFormatter<5, true>, unsigned long&>, txindex::BlockTxPosition&>(SpanReader&, Wrapper<CustomUintFormatter<5, true>, unsigned long&>&&, txindex::BlockTxPosition&)
Line
Count
Source
1086
326
    {
1087
326
        ::UnserializeMany(s, args...);
1088
326
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>, Wrapper<CustomUintFormatter<3, true>, unsigned int&>>(SpanReader&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&&, Wrapper<CustomUintFormatter<3, true>, unsigned int&>&&)
Line
Count
Source
1086
326
    {
1087
326
        ::UnserializeMany(s, args...);
1088
326
    }
void ActionUnserialize::SerReadWriteMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>, Wrapper<CustomUintFormatter<3, true>, unsigned int&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&&, Wrapper<CustomUintFormatter<3, true>, unsigned int&>&&)
Line
Count
Source
1086
4
    {
1087
4
        ::UnserializeMany(s, args...);
1088
4
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, int&>(SpanReader&, int&)
Line
Count
Source
1086
110
    {
1087
110
        ::UnserializeMany(s, args...);
1088
110
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, std::vector<uint256, std::allocator<uint256>>&>(SpanReader&, std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
1086
110
    {
1087
110
        ::UnserializeMany(s, args...);
1088
110
    }
void ActionUnserialize::SerReadWriteMany<AutoFile, Wrapper<AmountCompression, long&>, Wrapper<ScriptCompression, CScript&>>(AutoFile&, Wrapper<AmountCompression, long&>&&, Wrapper<ScriptCompression, CScript&>&&)
Line
Count
Source
1086
6.35k
    {
1087
6.35k
        ::UnserializeMany(s, args...);
1088
6.35k
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, uint256&>(SpanReader&, uint256&)
Line
Count
Source
1086
9.05k
    {
1087
9.05k
        ::UnserializeMany(s, args...);
1088
9.05k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, uint256&>(DataStream&, uint256&)
Line
Count
Source
1086
305k
    {
1087
305k
        ::UnserializeMany(s, args...);
1088
305k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, unsigned int&>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, unsigned int&)
Line
Count
Source
1086
20.5k
    {
1087
20.5k
        ::UnserializeMany(s, args...);
1088
20.5k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&&)
Line
Count
Source
1086
20.5k
    {
1087
20.5k
        ::UnserializeMany(s, args...);
1088
20.5k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&>&&)
Line
Count
Source
1086
20.5k
    {
1087
20.5k
        ::UnserializeMany(s, args...);
1088
20.5k
    }
Unexecuted instantiation: void ActionUnserialize::SerReadWriteMany<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&&)
void ActionUnserialize::SerReadWriteMany<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService>&&)
Line
Count
Source
1086
20.5k
    {
1087
20.5k
        ::UnserializeMany(s, args...);
1088
20.5k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>>(ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&&)
Line
Count
Source
1086
20.5k
    {
1087
20.5k
        ::UnserializeMany(s, args...);
1088
20.5k
    }
Unexecuted instantiation: void ActionUnserialize::SerReadWriteMany<ParamsStream<AutoFile&, CAddress::SerParams>, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>, int&>(ParamsStream<AutoFile&, CAddress::SerParams>&, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&&, int&)
Unexecuted instantiation: void ActionUnserialize::SerReadWriteMany<ParamsStream<AutoFile&, CAddress::SerParams>, unsigned int&>(ParamsStream<AutoFile&, CAddress::SerParams>&, unsigned int&)
Unexecuted instantiation: void ActionUnserialize::SerReadWriteMany<ParamsStream<AutoFile&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>>(ParamsStream<AutoFile&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&&)
Unexecuted instantiation: void ActionUnserialize::SerReadWriteMany<ParamsStream<AutoFile&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(ParamsStream<AutoFile&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&>&&)
Unexecuted instantiation: void ActionUnserialize::SerReadWriteMany<ParamsStream<AutoFile&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>>(ParamsStream<AutoFile&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&&)
Unexecuted instantiation: void ActionUnserialize::SerReadWriteMany<ParamsStream<AutoFile&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>>(ParamsStream<AutoFile&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService>&&)
Unexecuted instantiation: void ActionUnserialize::SerReadWriteMany<ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>>(ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&&)
void ActionUnserialize::SerReadWriteMany<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>, int&>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&&, int&)
Line
Count
Source
1086
20.5k
    {
1087
20.5k
        ::UnserializeMany(s, args...);
1088
20.5k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, CAddress::SerParams>, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>, int&>(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&&, int&)
Line
Count
Source
1086
14
    {
1087
14
        ::UnserializeMany(s, args...);
1088
14
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, CAddress::SerParams>, unsigned int&>(ParamsStream<DataStream&, CAddress::SerParams>&, unsigned int&)
Line
Count
Source
1086
14
    {
1087
14
        ::UnserializeMany(s, args...);
1088
14
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>>(ParamsStream<DataStream&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&&)
Line
Count
Source
1086
6.91k
    {
1087
6.91k
        ::UnserializeMany(s, args...);
1088
6.91k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(ParamsStream<DataStream&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&>&&)
Line
Count
Source
1086
1.03k
    {
1087
1.03k
        ::UnserializeMany(s, args...);
1088
1.03k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>>(ParamsStream<DataStream&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&&)
Line
Count
Source
1086
5.88k
    {
1087
5.88k
        ::UnserializeMany(s, args...);
1088
5.88k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>>(ParamsStream<DataStream&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService>&&)
Line
Count
Source
1086
6.91k
    {
1087
6.91k
        ::UnserializeMany(s, args...);
1088
6.91k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>>(ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&&)
Line
Count
Source
1086
6.91k
    {
1087
6.91k
        ::UnserializeMany(s, args...);
1088
6.91k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>, int&>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CAddress&, CNetAddr&, Wrapper<ChronoFormatter<long, false>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&&, int&)
Line
Count
Source
1086
5
    {
1087
5
        ::UnserializeMany(s, args...);
1088
5
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, unsigned int&>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, unsigned int&)
Line
Count
Source
1086
5
    {
1087
5
        ::UnserializeMany(s, args...);
1088
5
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, Wrapper<ChronoFormatter<unsigned int, true>, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1l>>>&>&&)
Line
Count
Source
1086
4
    {
1087
4
        ::UnserializeMany(s, args...);
1088
4
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, Wrapper<CompactSizeFormatter<false>, unsigned long&>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, Wrapper<CompactSizeFormatter<false>, unsigned long&>&&)
Line
Count
Source
1086
3
    {
1087
3
        ::UnserializeMany(s, args...);
1088
3
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, Wrapper<CustomUintFormatter<8, false>, ServiceFlags&>&&)
Line
Count
Source
1086
1
    {
1087
1
        ::UnserializeMany(s, args...);
1088
1
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, ParamsWrapper<CNetAddr::SerParams, CService>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, ParamsWrapper<CNetAddr::SerParams, CService>&&)
Line
Count
Source
1086
4
    {
1087
4
        ::UnserializeMany(s, args...);
1088
4
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>>(ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&&)
Line
Count
Source
1086
4
    {
1087
4
        ::UnserializeMany(s, args...);
1088
4
    }
void ActionUnserialize::SerReadWriteMany<DataStream, uint256&, uint256&, FlatFilePos&>(DataStream&, uint256&, uint256&, FlatFilePos&)
Line
Count
Source
1086
2.97k
    {
1087
2.97k
        ::UnserializeMany(s, args...);
1088
2.97k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>&&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&&)
Line
Count
Source
1086
2.97k
    {
1087
2.97k
        ::UnserializeMany(s, args...);
1088
2.97k
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, uint256&, uint256&, FlatFilePos&>(SpanReader&, uint256&, uint256&, FlatFilePos&)
Line
Count
Source
1086
1.06k
    {
1087
1.06k
        ::UnserializeMany(s, args...);
1088
1.06k
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(SpanReader&, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>&&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&&)
Line
Count
Source
1086
1.12k
    {
1087
1.12k
        ::UnserializeMany(s, args...);
1088
1.12k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, long&>(DataStream&, long&)
Line
Count
Source
1086
726
    {
1087
726
        ::UnserializeMany(s, args...);
1088
726
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, unsigned long&>(SpanReader&, unsigned long&)
Line
Count
Source
1086
3.54k
    {
1087
3.54k
        ::UnserializeMany(s, args...);
1088
3.54k
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, long&>(SpanReader&, long&)
Line
Count
Source
1086
1.34k
    {
1087
1.34k
        ::UnserializeMany(s, args...);
1088
1.34k
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, Num3072&>(SpanReader&, Num3072&)
Line
Count
Source
1086
64
    {
1087
64
        ::UnserializeMany(s, args...);
1088
64
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<AutoFile&, TransactionSerParams>, COutPoint&, CScript&, unsigned int&>(ParamsStream<AutoFile&, TransactionSerParams>&, COutPoint&, CScript&, unsigned int&)
Line
Count
Source
1086
517
    {
1087
517
        ::UnserializeMany(s, args...);
1088
517
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<AutoFile&, TransactionSerParams>, transaction_identifier<false>&, unsigned int&>(ParamsStream<AutoFile&, TransactionSerParams>&, transaction_identifier<false>&, unsigned int&)
Line
Count
Source
1086
517
    {
1087
517
        ::UnserializeMany(s, args...);
1088
517
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<AutoFile&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>&>(ParamsStream<AutoFile&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
1086
1.34k
    {
1087
1.34k
        ::UnserializeMany(s, args...);
1088
1.34k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<AutoFile&, TransactionSerParams>, long&, CScript&>(ParamsStream<AutoFile&, TransactionSerParams>&, long&, CScript&)
Line
Count
Source
1086
832
    {
1087
832
        ::UnserializeMany(s, args...);
1088
832
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, FlatFilePos&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(SpanReader&, FlatFilePos&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&&)
Line
Count
Source
1086
29
    {
1087
29
        ::UnserializeMany(s, args...);
1088
29
    }
void ActionUnserialize::SerReadWriteMany<AutoFile, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(AutoFile&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1086
24
    {
1087
24
        ::UnserializeMany(s, args...);
1088
24
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, CDiskTxPos&>(SpanReader&, CDiskTxPos&)
Line
Count
Source
1086
26
    {
1087
26
        ::UnserializeMany(s, args...);
1088
26
    }
Unexecuted instantiation: void ActionUnserialize::SerReadWriteMany<ParamsStream<SpanReader, CAddress::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>>(ParamsStream<SpanReader, CAddress::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&&)
void ActionUnserialize::SerReadWriteMany<DataStream, std::array<unsigned char, 4ul>&, char (&) [12], unsigned int&, unsigned char (&) [4]>(DataStream&, std::array<unsigned char, 4ul>&, char (&) [12], unsigned int&, unsigned char (&) [4])
Line
Count
Source
1086
129k
    {
1087
129k
        ::UnserializeMany(s, args...);
1088
129k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<DataStream&, CNetAddr::SerParams>, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>>(ParamsStream<DataStream&, CNetAddr::SerParams>&, CNetAddr&, Wrapper<CustomUintFormatter<2, true>, unsigned short&>&&)
Line
Count
Source
1086
1.73k
    {
1087
1.73k
        ::UnserializeMany(s, args...);
1088
1.73k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, unsigned int&, uint256&>(DataStream&, unsigned int&, uint256&)
Line
Count
Source
1086
167k
    {
1087
167k
        ::UnserializeMany(s, args...);
1088
167k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, std::vector<uint256, std::allocator<uint256>>&>(DataStream&, std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
1086
5.20k
    {
1087
5.20k
        ::UnserializeMany(s, args...);
1088
5.20k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, uint256&, ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>>>(DataStream&, uint256&, ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>>&&)
Line
Count
Source
1086
572
    {
1087
572
        ::UnserializeMany(s, args...);
1088
572
    }
void ActionUnserialize::SerReadWriteMany<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, unsigned char&>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, unsigned char&)
Line
Count
Source
1086
10
    {
1087
10
        ::UnserializeMany(s, args...);
1088
10
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(SpanReader&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&&)
Line
Count
Source
1086
4.19k
    {
1087
4.19k
        ::UnserializeMany(s, args...);
1088
4.19k
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>>(SpanReader&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>&&)
Line
Count
Source
1086
1.67k
    {
1087
1.67k
        ::UnserializeMany(s, args...);
1088
1.67k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)1>, int&>&&)
Line
Count
Source
1086
455k
    {
1087
455k
        ::UnserializeMany(s, args...);
1088
455k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(DataStream&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&&)
Line
Count
Source
1086
604k
    {
1087
604k
        ::UnserializeMany(s, args...);
1088
604k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, unsigned int&>(DataStream&, unsigned int&)
Line
Count
Source
1086
457k
    {
1087
457k
        ::UnserializeMany(s, args...);
1088
457k
    }
void ActionUnserialize::SerReadWriteMany<HashVerifier<BufferedReader<AutoFile>>, std::vector<CTxUndo, std::allocator<CTxUndo>>&>(HashVerifier<BufferedReader<AutoFile>>&, std::vector<CTxUndo, std::allocator<CTxUndo>>&)
Line
Count
Source
1086
33.7k
    {
1087
33.7k
        ::UnserializeMany(s, args...);
1088
33.7k
    }
void ActionUnserialize::SerReadWriteMany<HashVerifier<BufferedReader<AutoFile>>, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>>&>>(HashVerifier<BufferedReader<AutoFile>>&, Wrapper<VectorFormatter<TxInUndoFormatter>, std::vector<Coin, std::allocator<Coin>>&>&&)
Line
Count
Source
1086
21.0k
    {
1087
21.0k
        ::UnserializeMany(s, args...);
1088
21.0k
    }
void ActionUnserialize::SerReadWriteMany<HashVerifier<BufferedReader<AutoFile>>, Wrapper<AmountCompression, long&>, Wrapper<ScriptCompression, CScript&>>(HashVerifier<BufferedReader<AutoFile>>&, Wrapper<AmountCompression, long&>&&, Wrapper<ScriptCompression, CScript&>&&)
Line
Count
Source
1086
31.1k
    {
1087
31.1k
        ::UnserializeMany(s, args...);
1088
31.1k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<SpanReader&, TransactionSerParams>, CBlockHeader&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(ParamsStream<SpanReader&, TransactionSerParams>&, CBlockHeader&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
1086
140k
    {
1087
140k
        ::UnserializeMany(s, args...);
1088
140k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<SpanReader&, TransactionSerParams>, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(ParamsStream<SpanReader&, TransactionSerParams>&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1086
140k
    {
1087
140k
        ::UnserializeMany(s, args...);
1088
140k
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, CBlockHeader&, CPartialMerkleTree&>(SpanReader&, CBlockHeader&, CPartialMerkleTree&)
Line
Count
Source
1086
20
    {
1087
20
        ::UnserializeMany(s, args...);
1088
20
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(SpanReader&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1086
1.86k
    {
1087
1.86k
        ::UnserializeMany(s, args...);
1088
1.86k
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, unsigned int&, std::vector<uint256, std::allocator<uint256>>&>(SpanReader&, unsigned int&, std::vector<uint256, std::allocator<uint256>>&)
Line
Count
Source
1086
20
    {
1087
20
        ::UnserializeMany(s, args...);
1088
20
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, std::vector<unsigned char, std::allocator<unsigned char>>&>(SpanReader&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
1086
20
    {
1087
20
        ::UnserializeMany(s, args...);
1088
20
    }
void ActionUnserialize::SerReadWriteMany<SpanReader, unsigned char&, transaction_identifier<false>&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(SpanReader&, unsigned char&, transaction_identifier<false>&, Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>&&)
Line
Count
Source
1086
279k
    {
1087
279k
        ::UnserializeMany(s, args...);
1088
279k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, Wrapper<AmountCompression, long&>, Wrapper<ScriptCompression, CScript&>>(DataStream&, Wrapper<AmountCompression, long&>&&, Wrapper<ScriptCompression, CScript&>&&)
Line
Count
Source
1086
279k
    {
1087
279k
        ::UnserializeMany(s, args...);
1088
279k
    }
void ActionUnserialize::SerReadWriteMany<BufferedFile, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(BufferedFile&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1086
2.02k
    {
1087
2.02k
        ::UnserializeMany(s, args...);
1088
2.02k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<BufferedFile&, TransactionSerParams>, CBlockHeader&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>(ParamsStream<BufferedFile&, TransactionSerParams>&, CBlockHeader&, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&)
Line
Count
Source
1086
1.91k
    {
1087
1.91k
        ::UnserializeMany(s, args...);
1088
1.91k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<BufferedFile&, TransactionSerParams>, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&>(ParamsStream<BufferedFile&, TransactionSerParams>&, int&, uint256&, uint256&, unsigned int&, unsigned int&, unsigned int&)
Line
Count
Source
1086
1.91k
    {
1087
1.91k
        ::UnserializeMany(s, args...);
1088
1.91k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<BufferedFile&, TransactionSerParams>, COutPoint&, CScript&, unsigned int&>(ParamsStream<BufferedFile&, TransactionSerParams>&, COutPoint&, CScript&, unsigned int&)
Line
Count
Source
1086
2.01k
    {
1087
2.01k
        ::UnserializeMany(s, args...);
1088
2.01k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<BufferedFile&, TransactionSerParams>, transaction_identifier<false>&, unsigned int&>(ParamsStream<BufferedFile&, TransactionSerParams>&, transaction_identifier<false>&, unsigned int&)
Line
Count
Source
1086
2.01k
    {
1087
2.01k
        ::UnserializeMany(s, args...);
1088
2.01k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<BufferedFile&, TransactionSerParams>, prevector<36u, unsigned char, unsigned int, int>&>(ParamsStream<BufferedFile&, TransactionSerParams>&, prevector<36u, unsigned char, unsigned int, int>&)
Line
Count
Source
1086
5.97k
    {
1087
5.97k
        ::UnserializeMany(s, args...);
1088
5.97k
    }
void ActionUnserialize::SerReadWriteMany<ParamsStream<BufferedFile&, TransactionSerParams>, long&, CScript&>(ParamsStream<BufferedFile&, TransactionSerParams>&, long&, CScript&)
Line
Count
Source
1086
3.96k
    {
1087
3.96k
        ::UnserializeMany(s, args...);
1088
3.96k
    }
void ActionUnserialize::SerReadWriteMany<DataStream, int&, long&>(DataStream&, int&, long&)
Line
Count
Source
1086
376
    {
1087
376
        ::UnserializeMany(s, args...);
1088
376
    }
void ActionUnserialize::SerReadWriteMany<DataStream, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, CKeyID&>(DataStream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, CKeyID&)
Line
Count
Source
1086
376
    {
1087
376
        ::UnserializeMany(s, args...);
1088
376
    }
void ActionUnserialize::SerReadWriteMany<DataStream, KeyOriginInfo&>(DataStream&, KeyOriginInfo&)
Line
Count
Source
1086
277
    {
1087
277
        ::UnserializeMany(s, args...);
1088
277
    }
void ActionUnserialize::SerReadWriteMany<DataStream, std::array<unsigned char, 4ul>&, std::vector<unsigned int, std::allocator<unsigned int>>&>(DataStream&, std::array<unsigned char, 4ul>&, std::vector<unsigned int, std::allocator<unsigned int>>&)
Line
Count
Source
1086
277
    {
1087
277
        ::UnserializeMany(s, args...);
1088
277
    }
void ActionUnserialize::SerReadWriteMany<DataStream, std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, std::vector<unsigned char, std::allocator<unsigned char>>&>(DataStream&, std::vector<unsigned char, std::allocator<unsigned char>>&, std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned int&, unsigned int&, std::vector<unsigned char, std::allocator<unsigned char>>&)
Line
Count
Source
1086
27
    {
1087
27
        ::UnserializeMany(s, args...);
1088
27
    }
void ActionUnserialize::SerReadWriteMany<DataStream, int&, unsigned int&, CKeyID&>(DataStream&, int&, unsigned int&, CKeyID&)
Line
Count
Source
1086
38
    {
1087
38
        ::UnserializeMany(s, args...);
1088
38
    }
1089
1090
    template<typename Stream, typename Type, typename Fn>
1091
    static void SerRead(Stream& s, Type&& obj, Fn&& fn)
1092
22.9k
    {
1093
22.9k
        fn(s, std::forward<Type>(obj));
1094
22.9k
    }
void ActionUnserialize::SerRead<ParamsStream<SpanReader&, CAddress::SerParams>, CAddress&, void CAddress::SerializationOps<ParamsStream<SpanReader&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<SpanReader&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<SpanReader&, CAddress::SerParams>&, CAddress&)>(ParamsStream<SpanReader&, CAddress::SerParams>&, CAddress&&, ActionUnserialize&&)
Line
Count
Source
1092
3
    {
1093
3
        fn(s, std::forward<Type>(obj));
1094
3
    }
void ActionUnserialize::SerRead<DataStream, CPartialMerkleTree&, void CPartialMerkleTree::SerializationOps<DataStream, CPartialMerkleTree, ActionUnserialize>(CPartialMerkleTree&, DataStream&, ActionUnserialize)::'lambda'(DataStream&, CPartialMerkleTree&)>(DataStream&, CPartialMerkleTree&&, ActionUnserialize&&)
Line
Count
Source
1092
168
    {
1093
168
        fn(s, std::forward<Type>(obj));
1094
168
    }
void ActionUnserialize::SerRead<DataStream, CPartialMerkleTree&, void CPartialMerkleTree::SerializationOps<DataStream, CPartialMerkleTree, ActionUnserialize>(CPartialMerkleTree&, DataStream&, ActionUnserialize)::'lambda0'(DataStream&, CPartialMerkleTree&)>(DataStream&, CPartialMerkleTree&&, ActionUnserialize&&)
Line
Count
Source
1092
168
    {
1093
168
        fn(s, std::forward<Type>(obj));
1094
168
    }
void ActionUnserialize::SerRead<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, CAddress&, void CAddress::SerializationOps<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CAddress&)>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CAddress&&, ActionUnserialize&&)
Line
Count
Source
1092
20.5k
    {
1093
20.5k
        fn(s, std::forward<Type>(obj));
1094
20.5k
    }
Unexecuted instantiation: void ActionUnserialize::SerRead<ParamsStream<AutoFile&, CAddress::SerParams>, CAddress&, void CAddress::SerializationOps<ParamsStream<AutoFile&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<AutoFile&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<AutoFile&, CAddress::SerParams>&, CAddress&)>(ParamsStream<AutoFile&, CAddress::SerParams>&, CAddress&&, ActionUnserialize&&)
void ActionUnserialize::SerRead<ParamsStream<DataStream&, CAddress::SerParams>, CAddress&, void CAddress::SerializationOps<ParamsStream<DataStream&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<DataStream&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress&)>(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress&&, ActionUnserialize&&)
Line
Count
Source
1092
1.03k
    {
1093
1.03k
        fn(s, std::forward<Type>(obj));
1094
1.03k
    }
void ActionUnserialize::SerRead<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, CAddress&, void CAddress::SerializationOps<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CAddress&)>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CAddress&&, ActionUnserialize&&)
Line
Count
Source
1092
3
    {
1093
3
        fn(s, std::forward<Type>(obj));
1094
3
    }
coinstatsindex.cpp:void ActionUnserialize::SerRead<DataStream, (anonymous namespace)::DBVal&, void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, DataStream&, ActionUnserialize)::'lambda'(DataStream&, (anonymous namespace)::DBVal&)>(DataStream&, (anonymous namespace)::DBVal&&, ActionUnserialize&&)
Line
Count
Source
1092
121
    {
1093
121
        fn(s, std::forward<Type>(obj));
1094
121
    }
coinstatsindex.cpp:void ActionUnserialize::SerRead<DataStream, (anonymous namespace)::DBVal&, void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, DataStream&, ActionUnserialize)::'lambda0'(DataStream&, (anonymous namespace)::DBVal&)>(DataStream&, (anonymous namespace)::DBVal&&, ActionUnserialize&&)
Line
Count
Source
1092
121
    {
1093
121
        fn(s, std::forward<Type>(obj));
1094
121
    }
coinstatsindex.cpp:void ActionUnserialize::SerRead<DataStream, (anonymous namespace)::DBVal&, void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, DataStream&, ActionUnserialize)::'lambda1'(DataStream&, (anonymous namespace)::DBVal&)>(DataStream&, (anonymous namespace)::DBVal&&, ActionUnserialize&&)
Line
Count
Source
1092
121
    {
1093
121
        fn(s, std::forward<Type>(obj));
1094
121
    }
coinstatsindex.cpp:void ActionUnserialize::SerRead<SpanReader, (anonymous namespace)::DBVal&, void (anonymous namespace)::DBVal::SerializationOps<SpanReader, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, SpanReader&, ActionUnserialize)::'lambda'(SpanReader&, (anonymous namespace)::DBVal&)>(SpanReader&, (anonymous namespace)::DBVal&&, ActionUnserialize&&)
Line
Count
Source
1092
224
    {
1093
224
        fn(s, std::forward<Type>(obj));
1094
224
    }
coinstatsindex.cpp:void ActionUnserialize::SerRead<SpanReader, (anonymous namespace)::DBVal&, void (anonymous namespace)::DBVal::SerializationOps<SpanReader, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, SpanReader&, ActionUnserialize)::'lambda0'(SpanReader&, (anonymous namespace)::DBVal&)>(SpanReader&, (anonymous namespace)::DBVal&&, ActionUnserialize&&)
Line
Count
Source
1092
224
    {
1093
224
        fn(s, std::forward<Type>(obj));
1094
224
    }
coinstatsindex.cpp:void ActionUnserialize::SerRead<SpanReader, (anonymous namespace)::DBVal&, void (anonymous namespace)::DBVal::SerializationOps<SpanReader, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, SpanReader&, ActionUnserialize)::'lambda1'(SpanReader&, (anonymous namespace)::DBVal&)>(SpanReader&, (anonymous namespace)::DBVal&&, ActionUnserialize&&)
Line
Count
Source
1092
224
    {
1093
224
        fn(s, std::forward<Type>(obj));
1094
224
    }
void ActionUnserialize::SerRead<SpanReader, CPartialMerkleTree&, void CPartialMerkleTree::SerializationOps<SpanReader, CPartialMerkleTree, ActionUnserialize>(CPartialMerkleTree&, SpanReader&, ActionUnserialize)::'lambda'(SpanReader&, CPartialMerkleTree&)>(SpanReader&, CPartialMerkleTree&&, ActionUnserialize&&)
Line
Count
Source
1092
20
    {
1093
20
        fn(s, std::forward<Type>(obj));
1094
20
    }
void ActionUnserialize::SerRead<SpanReader, CPartialMerkleTree&, void CPartialMerkleTree::SerializationOps<SpanReader, CPartialMerkleTree, ActionUnserialize>(CPartialMerkleTree&, SpanReader&, ActionUnserialize)::'lambda0'(SpanReader&, CPartialMerkleTree&)>(SpanReader&, CPartialMerkleTree&&, ActionUnserialize&&)
Line
Count
Source
1092
20
    {
1093
20
        fn(s, std::forward<Type>(obj));
1094
20
    }
1095
1096
    template<typename Stream, typename Type, typename Fn>
1097
    static void SerWrite(Stream& s, Type&&, Fn&&)
1098
22.8k
    {
1099
22.8k
    }
void ActionUnserialize::SerWrite<ParamsStream<SpanReader&, CAddress::SerParams>, CAddress&, void CAddress::SerializationOps<ParamsStream<SpanReader&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<SpanReader&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<SpanReader&, CAddress::SerParams>&, CAddress const&)>(ParamsStream<SpanReader&, CAddress::SerParams>&, CAddress&&, ActionUnserialize&&)
Line
Count
Source
1098
3
    {
1099
3
    }
void ActionUnserialize::SerWrite<DataStream, CPartialMerkleTree&, void CPartialMerkleTree::SerializationOps<DataStream, CPartialMerkleTree, ActionUnserialize>(CPartialMerkleTree&, DataStream&, ActionUnserialize)::'lambda'(DataStream&, CPartialMerkleTree const&)>(DataStream&, CPartialMerkleTree&&, ActionUnserialize&&)
Line
Count
Source
1098
168
    {
1099
168
    }
void ActionUnserialize::SerWrite<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, CAddress&, void CAddress::SerializationOps<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CAddress const&)>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CAddress&&, ActionUnserialize&&)
Line
Count
Source
1098
20.5k
    {
1099
20.5k
    }
Unexecuted instantiation: void ActionUnserialize::SerWrite<ParamsStream<AutoFile&, CAddress::SerParams>, CAddress&, void CAddress::SerializationOps<ParamsStream<AutoFile&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<AutoFile&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<AutoFile&, CAddress::SerParams>&, CAddress const&)>(ParamsStream<AutoFile&, CAddress::SerParams>&, CAddress&&, ActionUnserialize&&)
void ActionUnserialize::SerWrite<ParamsStream<DataStream&, CAddress::SerParams>, CAddress&, void CAddress::SerializationOps<ParamsStream<DataStream&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<DataStream&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress const&)>(ParamsStream<DataStream&, CAddress::SerParams>&, CAddress&&, ActionUnserialize&&)
Line
Count
Source
1098
1.03k
    {
1099
1.03k
    }
void ActionUnserialize::SerWrite<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, CAddress&, void CAddress::SerializationOps<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>, CAddress, ActionUnserialize>(CAddress&, ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, ActionUnserialize)::'lambda'(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CAddress const&)>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CAddress&&, ActionUnserialize&&)
Line
Count
Source
1098
3
    {
1099
3
    }
coinstatsindex.cpp:void ActionUnserialize::SerWrite<DataStream, (anonymous namespace)::DBVal&, void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, DataStream&, ActionUnserialize)::'lambda'(DataStream&, (anonymous namespace)::DBVal const&)>(DataStream&, (anonymous namespace)::DBVal&&, ActionUnserialize&&)
Line
Count
Source
1098
121
    {
1099
121
    }
coinstatsindex.cpp:void ActionUnserialize::SerWrite<DataStream, (anonymous namespace)::DBVal&, void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, DataStream&, ActionUnserialize)::'lambda0'(DataStream&, (anonymous namespace)::DBVal const&)>(DataStream&, (anonymous namespace)::DBVal&&, ActionUnserialize&&)
Line
Count
Source
1098
121
    {
1099
121
    }
coinstatsindex.cpp:void ActionUnserialize::SerWrite<DataStream, (anonymous namespace)::DBVal&, void (anonymous namespace)::DBVal::SerializationOps<DataStream, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, DataStream&, ActionUnserialize)::'lambda1'(DataStream&, (anonymous namespace)::DBVal const&)>(DataStream&, (anonymous namespace)::DBVal&&, ActionUnserialize&&)
Line
Count
Source
1098
121
    {
1099
121
    }
coinstatsindex.cpp:void ActionUnserialize::SerWrite<SpanReader, (anonymous namespace)::DBVal&, void (anonymous namespace)::DBVal::SerializationOps<SpanReader, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, SpanReader&, ActionUnserialize)::'lambda'(SpanReader&, (anonymous namespace)::DBVal const&)>(SpanReader&, (anonymous namespace)::DBVal&&, ActionUnserialize&&)
Line
Count
Source
1098
224
    {
1099
224
    }
coinstatsindex.cpp:void ActionUnserialize::SerWrite<SpanReader, (anonymous namespace)::DBVal&, void (anonymous namespace)::DBVal::SerializationOps<SpanReader, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, SpanReader&, ActionUnserialize)::'lambda0'(SpanReader&, (anonymous namespace)::DBVal const&)>(SpanReader&, (anonymous namespace)::DBVal&&, ActionUnserialize&&)
Line
Count
Source
1098
224
    {
1099
224
    }
coinstatsindex.cpp:void ActionUnserialize::SerWrite<SpanReader, (anonymous namespace)::DBVal&, void (anonymous namespace)::DBVal::SerializationOps<SpanReader, (anonymous namespace)::DBVal, ActionUnserialize>((anonymous namespace)::DBVal&, SpanReader&, ActionUnserialize)::'lambda1'(SpanReader&, (anonymous namespace)::DBVal const&)>(SpanReader&, (anonymous namespace)::DBVal&&, ActionUnserialize&&)
Line
Count
Source
1098
224
    {
1099
224
    }
void ActionUnserialize::SerWrite<SpanReader, CPartialMerkleTree&, void CPartialMerkleTree::SerializationOps<SpanReader, CPartialMerkleTree, ActionUnserialize>(CPartialMerkleTree&, SpanReader&, ActionUnserialize)::'lambda'(SpanReader&, CPartialMerkleTree const&)>(SpanReader&, CPartialMerkleTree&&, ActionUnserialize&&)
Line
Count
Source
1098
20
    {
1099
20
    }
1100
};
1101
1102
/* ::GetSerializeSize implementations
1103
 *
1104
 * Computing the serialized size of objects is done through a special stream
1105
 * object of type SizeComputer, which only records the number of bytes written
1106
 * to it.
1107
 *
1108
 * If your Serialize or SerializationOp method has non-trivial overhead for
1109
 * serialization, it may be worthwhile to implement a specialized version for
1110
 * SizeComputer, which uses the s.seek() method to record bytes that would
1111
 * be written instead.
1112
 */
1113
class SizeComputer
1114
{
1115
protected:
1116
    uint64_t m_size{0};
1117
1118
public:
1119
4.10M
    SizeComputer() = default;
1120
1121
    void write(std::span<const std::byte> src)
1122
73.2M
    {
1123
73.2M
        m_size += src.size();
1124
73.2M
    }
1125
1126
    /** Pretend this many bytes are written, without specifying them. */
1127
    void seek(uint64_t num)
1128
2.07M
    {
1129
2.07M
        m_size += num;
1130
2.07M
    }
1131
1132
    template <typename T>
1133
    SizeComputer& operator<<(const T& obj)
1134
4.35M
    {
1135
4.35M
        ::Serialize(*this, obj);
1136
4.35M
        return *this;
1137
4.35M
    }
SizeComputer& SizeComputer::operator<<<ParamsWrapper<TransactionSerParams, CTransaction const>>(ParamsWrapper<TransactionSerParams, CTransaction const> const&)
Line
Count
Source
1134
2.57M
    {
1135
2.57M
        ::Serialize(*this, obj);
1136
2.57M
        return *this;
1137
2.57M
    }
SizeComputer& SizeComputer::operator<<<ParamsWrapper<TransactionSerParams, CBlock const>>(ParamsWrapper<TransactionSerParams, CBlock const> const&)
Line
Count
Source
1134
710k
    {
1135
710k
        ::Serialize(*this, obj);
1136
710k
        return *this;
1137
710k
    }
SizeComputer& SizeComputer::operator<<<ParamsWrapper<TransactionSerParams, CTxIn const>>(ParamsWrapper<TransactionSerParams, CTxIn const> const&)
Line
Count
Source
1134
4.99k
    {
1135
4.99k
        ::Serialize(*this, obj);
1136
4.99k
        return *this;
1137
4.99k
    }
SizeComputer& SizeComputer::operator<<<std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
1134
116k
    {
1135
116k
        ::Serialize(*this, obj);
1136
116k
        return *this;
1137
116k
    }
SizeComputer& SizeComputer::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
1134
1
    {
1135
1
        ::Serialize(*this, obj);
1136
1
        return *this;
1137
1
    }
SizeComputer& SizeComputer::operator<<<ParamsWrapper<TransactionSerParams, CMutableTransaction>>(ParamsWrapper<TransactionSerParams, CMutableTransaction> const&)
Line
Count
Source
1134
2
    {
1135
2
        ::Serialize(*this, obj);
1136
2
        return *this;
1137
2
    }
SizeComputer& SizeComputer::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1134
8
    {
1135
8
        ::Serialize(*this, obj);
1136
8
        return *this;
1137
8
    }
SizeComputer& SizeComputer::operator<<<signed char>(signed char const&)
Line
Count
Source
1134
2
    {
1135
2
        ::Serialize(*this, obj);
1136
2
        return *this;
1137
2
    }
SizeComputer& SizeComputer::operator<<<short>(short const&)
Line
Count
Source
1134
2
    {
1135
2
        ::Serialize(*this, obj);
1136
2
        return *this;
1137
2
    }
SizeComputer& SizeComputer::operator<<<unsigned short>(unsigned short const&)
Line
Count
Source
1134
2
    {
1135
2
        ::Serialize(*this, obj);
1136
2
        return *this;
1137
2
    }
SizeComputer& SizeComputer::operator<<<int>(int const&)
Line
Count
Source
1134
2
    {
1135
2
        ::Serialize(*this, obj);
1136
2
        return *this;
1137
2
    }
SizeComputer& SizeComputer::operator<<<unsigned int>(unsigned int const&)
Line
Count
Source
1134
2
    {
1135
2
        ::Serialize(*this, obj);
1136
2
        return *this;
1137
2
    }
SizeComputer& SizeComputer::operator<<<long>(long const&)
Line
Count
Source
1134
2
    {
1135
2
        ::Serialize(*this, obj);
1136
2
        return *this;
1137
2
    }
SizeComputer& SizeComputer::operator<<<unsigned long>(unsigned long const&)
Line
Count
Source
1134
2
    {
1135
2
        ::Serialize(*this, obj);
1136
2
        return *this;
1137
2
    }
SizeComputer& SizeComputer::operator<<<bool>(bool const&)
Line
Count
Source
1134
2
    {
1135
2
        ::Serialize(*this, obj);
1136
2
        return *this;
1137
2
    }
SizeComputer& SizeComputer::operator<<<std::array<unsigned char, 1ul>>(std::array<unsigned char, 1ul> const&)
Line
Count
Source
1134
1
    {
1135
1
        ::Serialize(*this, obj);
1136
1
        return *this;
1137
1
    }
SizeComputer& SizeComputer::operator<<<std::array<unsigned char, 2ul>>(std::array<unsigned char, 2ul> const&)
Line
Count
Source
1134
1
    {
1135
1
        ::Serialize(*this, obj);
1136
1
        return *this;
1137
1
    }
SizeComputer& SizeComputer::operator<<<Wrapper<VarIntFormatter<(VarIntMode)1>, int&>>(Wrapper<VarIntFormatter<(VarIntMode)1>, int&> const&)
Line
Count
Source
1134
100k
    {
1135
100k
        ::Serialize(*this, obj);
1136
100k
        return *this;
1137
100k
    }
SizeComputer& SizeComputer::operator<<<Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>>(Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> const&)
Line
Count
Source
1134
69.6k
    {
1135
69.6k
        ::Serialize(*this, obj);
1136
69.6k
        return *this;
1137
69.6k
    }
SizeComputer& SizeComputer::operator<<<ParamsWrapper<TransactionSerParams, CTransaction>>(ParamsWrapper<TransactionSerParams, CTransaction> const&)
Line
Count
Source
1134
1
    {
1135
1
        ::Serialize(*this, obj);
1136
1
        return *this;
1137
1
    }
SizeComputer& SizeComputer::operator<<<CBlockHeader>(CBlockHeader const&)
Line
Count
Source
1134
1
    {
1135
1
        ::Serialize(*this, obj);
1136
1
        return *this;
1137
1
    }
SizeComputer& SizeComputer::operator<<<std::span<unsigned char const, 32ul>>(std::span<unsigned char const, 32ul> const&)
Line
Count
Source
1134
88.7k
    {
1135
88.7k
        ::Serialize(*this, obj);
1136
88.7k
        return *this;
1137
88.7k
    }
SizeComputer& SizeComputer::operator<<<uint256>(uint256 const&)
Line
Count
Source
1134
8.00k
    {
1135
8.00k
        ::Serialize(*this, obj);
1136
8.00k
        return *this;
1137
8.00k
    }
SizeComputer& SizeComputer::operator<<<uint160>(uint160 const&)
Line
Count
Source
1134
2
    {
1135
2
        ::Serialize(*this, obj);
1136
2
        return *this;
1137
2
    }
SizeComputer& SizeComputer::operator<<<std::span<unsigned char const, 20ul>>(std::span<unsigned char const, 20ul> const&)
Line
Count
Source
1134
2
    {
1135
2
        ::Serialize(*this, obj);
1136
2
        return *this;
1137
2
    }
SizeComputer& SizeComputer::operator<<<ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>>(ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>> const&)
Line
Count
Source
1134
1
    {
1135
1
        ::Serialize(*this, obj);
1136
1
        return *this;
1137
1
    }
SizeComputer& SizeComputer::operator<<<std::array<unsigned char, 4ul>>(std::array<unsigned char, 4ul> const&)
Line
Count
Source
1134
4
    {
1135
4
        ::Serialize(*this, obj);
1136
4
        return *this;
1137
4
    }
SizeComputer& SizeComputer::operator<<<Wrapper<CustomUintFormatter<4, true>, unsigned int const&>>(Wrapper<CustomUintFormatter<4, true>, unsigned int const&> const&)
Line
Count
Source
1134
4
    {
1135
4
        ::Serialize(*this, obj);
1136
4
        return *this;
1137
4
    }
SizeComputer& SizeComputer::operator<<<ChainCode>(ChainCode const&)
Line
Count
Source
1134
4
    {
1135
4
        ::Serialize(*this, obj);
1136
4
        return *this;
1137
4
    }
SizeComputer& SizeComputer::operator<<<std::span<unsigned char const, 18446744073709551615ul>>(std::span<unsigned char const, 18446744073709551615ul> const&)
Line
Count
Source
1134
60.4k
    {
1135
60.4k
        ::Serialize(*this, obj);
1136
60.4k
        return *this;
1137
60.4k
    }
SizeComputer& SizeComputer::operator<<<CBlockHeaderAndShortTxIDs>(CBlockHeaderAndShortTxIDs const&)
Line
Count
Source
1134
35.6k
    {
1135
35.6k
        ::Serialize(*this, obj);
1136
35.6k
        return *this;
1137
35.6k
    }
SizeComputer& SizeComputer::operator<<<std::vector<unsigned char, std::allocator<unsigned char>>>(std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
1134
8.00k
    {
1135
8.00k
        ::Serialize(*this, obj);
1136
8.00k
        return *this;
1137
8.00k
    }
SizeComputer& SizeComputer::operator<<<CBlockUndo>(CBlockUndo const&)
Line
Count
Source
1134
100k
    {
1135
100k
        ::Serialize(*this, obj);
1136
100k
        return *this;
1137
100k
    }
SizeComputer& SizeComputer::operator<<<std::span<unsigned char, 18446744073709551615ul>>(std::span<unsigned char, 18446744073709551615ul> const&)
Line
Count
Source
1134
9.16k
    {
1135
9.16k
        ::Serialize(*this, obj);
1136
9.16k
        return *this;
1137
9.16k
    }
SizeComputer& SizeComputer::operator<<<Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&>>(Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned int&> const&)
Line
Count
Source
1134
60.4k
    {
1135
60.4k
        ::Serialize(*this, obj);
1136
60.4k
        return *this;
1137
60.4k
    }
SizeComputer& SizeComputer::operator<<<CTxOut>(CTxOut const&)
Line
Count
Source
1134
401k
    {
1135
401k
        ::Serialize(*this, obj);
1136
401k
        return *this;
1137
401k
    }
SizeComputer& SizeComputer::operator<<<ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const>>(ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const> const&)
Line
Count
Source
1134
4
    {
1135
4
        ::Serialize(*this, obj);
1136
4
        return *this;
1137
4
    }
1138
1139
    uint64_t size() const
1140
4.10M
    {
1141
4.10M
        return m_size;
1142
4.10M
    }
1143
};
1144
1145
template<typename I>
1146
inline void WriteVarInt(SizeComputer &s, I n)
1147
{
1148
    s.seek(GetSizeOfVarInt<I>(n));
1149
}
1150
1151
inline void WriteCompactSize(SizeComputer &s, uint64_t nSize)
1152
2.07M
{
1153
2.07M
    s.seek(GetSizeOfCompactSize(nSize));
1154
2.07M
}
1155
1156
template <typename T>
1157
uint64_t GetSerializeSize(const T& t)
1158
4.06M
{
1159
4.06M
    return (SizeComputer() << t).size();
1160
4.06M
}
unsigned long GetSerializeSize<ParamsWrapper<TransactionSerParams, CTransaction const>>(ParamsWrapper<TransactionSerParams, CTransaction const> const&)
Line
Count
Source
1158
2.57M
{
1159
2.57M
    return (SizeComputer() << t).size();
1160
2.57M
}
unsigned long GetSerializeSize<ParamsWrapper<TransactionSerParams, CBlock const>>(ParamsWrapper<TransactionSerParams, CBlock const> const&)
Line
Count
Source
1158
710k
{
1159
710k
    return (SizeComputer() << t).size();
1160
710k
}
unsigned long GetSerializeSize<ParamsWrapper<TransactionSerParams, CTxIn const>>(ParamsWrapper<TransactionSerParams, CTxIn const> const&)
Line
Count
Source
1158
4.99k
{
1159
4.99k
    return (SizeComputer() << t).size();
1160
4.99k
}
unsigned long GetSerializeSize<std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
1158
116k
{
1159
116k
    return (SizeComputer() << t).size();
1160
116k
}
unsigned long GetSerializeSize<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
1158
1
{
1159
1
    return (SizeComputer() << t).size();
1160
1
}
unsigned long GetSerializeSize<ParamsWrapper<TransactionSerParams, CMutableTransaction>>(ParamsWrapper<TransactionSerParams, CMutableTransaction> const&)
Line
Count
Source
1158
2
{
1159
2
    return (SizeComputer() << t).size();
1160
2
}
unsigned long GetSerializeSize<unsigned char>(unsigned char const&)
Line
Count
Source
1158
4
{
1159
4
    return (SizeComputer() << t).size();
1160
4
}
unsigned long GetSerializeSize<signed char>(signed char const&)
Line
Count
Source
1158
2
{
1159
2
    return (SizeComputer() << t).size();
1160
2
}
unsigned long GetSerializeSize<short>(short const&)
Line
Count
Source
1158
2
{
1159
2
    return (SizeComputer() << t).size();
1160
2
}
unsigned long GetSerializeSize<unsigned short>(unsigned short const&)
Line
Count
Source
1158
2
{
1159
2
    return (SizeComputer() << t).size();
1160
2
}
unsigned long GetSerializeSize<int>(int const&)
Line
Count
Source
1158
2
{
1159
2
    return (SizeComputer() << t).size();
1160
2
}
unsigned long GetSerializeSize<unsigned int>(unsigned int const&)
Line
Count
Source
1158
2
{
1159
2
    return (SizeComputer() << t).size();
1160
2
}
unsigned long GetSerializeSize<long>(long const&)
Line
Count
Source
1158
2
{
1159
2
    return (SizeComputer() << t).size();
1160
2
}
unsigned long GetSerializeSize<unsigned long>(unsigned long const&)
Line
Count
Source
1158
2
{
1159
2
    return (SizeComputer() << t).size();
1160
2
}
unsigned long GetSerializeSize<bool>(bool const&)
Line
Count
Source
1158
2
{
1159
2
    return (SizeComputer() << t).size();
1160
2
}
unsigned long GetSerializeSize<std::array<unsigned char, 1ul>>(std::array<unsigned char, 1ul> const&)
Line
Count
Source
1158
1
{
1159
1
    return (SizeComputer() << t).size();
1160
1
}
unsigned long GetSerializeSize<std::array<unsigned char, 2ul>>(std::array<unsigned char, 2ul> const&)
Line
Count
Source
1158
1
{
1159
1
    return (SizeComputer() << t).size();
1160
1
}
unsigned long GetSerializeSize<Wrapper<VarIntFormatter<(VarIntMode)1>, int&>>(Wrapper<VarIntFormatter<(VarIntMode)1>, int&> const&)
Line
Count
Source
1158
100k
{
1159
100k
    return (SizeComputer() << t).size();
1160
100k
}
unsigned long GetSerializeSize<Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&>>(Wrapper<VarIntFormatter<(VarIntMode)0>, unsigned long&> const&)
Line
Count
Source
1158
101
{
1159
101
    return (SizeComputer() << t).size();
1160
101
}
unsigned long GetSerializeSize<ParamsWrapper<TransactionSerParams, CTransaction>>(ParamsWrapper<TransactionSerParams, CTransaction> const&)
Line
Count
Source
1158
1
{
1159
1
    return (SizeComputer() << t).size();
1160
1
}
unsigned long GetSerializeSize<CBlockHeader>(CBlockHeader const&)
Line
Count
Source
1158
1
{
1159
1
    return (SizeComputer() << t).size();
1160
1
}
unsigned long GetSerializeSize<uint256>(uint256 const&)
Line
Count
Source
1158
8.00k
{
1159
8.00k
    return (SizeComputer() << t).size();
1160
8.00k
}
unsigned long GetSerializeSize<uint160>(uint160 const&)
Line
Count
Source
1158
2
{
1159
2
    return (SizeComputer() << t).size();
1160
2
}
unsigned long GetSerializeSize<ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>>(ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>> const&)
Line
Count
Source
1158
1
{
1159
1
    return (SizeComputer() << t).size();
1160
1
}
unsigned long GetSerializeSize<CBlockHeaderAndShortTxIDs>(CBlockHeaderAndShortTxIDs const&)
Line
Count
Source
1158
35.6k
{
1159
35.6k
    return (SizeComputer() << t).size();
1160
35.6k
}
unsigned long GetSerializeSize<std::vector<unsigned char, std::allocator<unsigned char>>>(std::vector<unsigned char, std::allocator<unsigned char>> const&)
Line
Count
Source
1158
8.00k
{
1159
8.00k
    return (SizeComputer() << t).size();
1160
8.00k
}
unsigned long GetSerializeSize<CBlockUndo>(CBlockUndo const&)
Line
Count
Source
1158
100k
{
1159
100k
    return (SizeComputer() << t).size();
1160
100k
}
unsigned long GetSerializeSize<CTxOut>(CTxOut const&)
Line
Count
Source
1158
401k
{
1159
401k
    return (SizeComputer() << t).size();
1160
401k
}
unsigned long GetSerializeSize<ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const>>(ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const> const&)
Line
Count
Source
1158
4
{
1159
4
    return (SizeComputer() << t).size();
1160
4
}
1161
1162
//! Check if type contains a stream by seeing if has a GetStream() method.
1163
template<typename T>
1164
concept ContainsStream = requires(T t) { t.GetStream(); };
1165
1166
/** Wrapper that overrides the GetParams() function of a stream. */
1167
template <typename SubStream, typename Params>
1168
class ParamsStream
1169
{
1170
    const Params& m_params;
1171
    // If ParamsStream constructor is passed an lvalue argument, Substream will
1172
    // be a reference type, and m_substream will reference that argument.
1173
    // Otherwise m_substream will be a substream instance and move from the
1174
    // argument. Letting ParamsStream contain a substream instance instead of
1175
    // just a reference is useful to make the ParamsStream object self contained
1176
    // and let it do cleanup when destroyed, for example by closing files if
1177
    // SubStream is a file stream.
1178
    SubStream m_substream;
1179
1180
public:
1181
6.38M
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<DataStream&, CAddress::SerParams>::ParamsStream(DataStream&, CAddress::SerParams const&)
Line
Count
Source
1181
106
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::ParamsStream(ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams const&)
Line
Count
Source
1181
6.94k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<DataStream&, TransactionSerParams>::ParamsStream(DataStream&, TransactionSerParams const&)
Line
Count
Source
1181
193k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<SizeComputer&, TransactionSerParams>::ParamsStream(SizeComputer&, TransactionSerParams const&)
Line
Count
Source
1181
3.32M
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<VectorWriter&, TransactionSerParams>::ParamsStream(VectorWriter&, TransactionSerParams const&)
Line
Count
Source
1181
46.9k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<HashWriter&, TransactionSerParams>::ParamsStream(HashWriter&, TransactionSerParams const&)
Line
Count
Source
1181
2.41M
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<VectorWriter&, CAddress::SerParams>::ParamsStream(VectorWriter&, CAddress::SerParams const&)
Line
Count
Source
1181
135
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<SpanReader&, CAddress::SerParams>::ParamsStream(SpanReader&, CAddress::SerParams const&)
Line
Count
Source
1181
3
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>::ParamsStream(ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams const&)
Line
Count
Source
1181
7
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<SpanReader&, TransactionSerParams>::ParamsStream(SpanReader&, TransactionSerParams const&)
Line
Count
Source
1181
187k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<DataStream&, serialize_tests::OtherParam>::ParamsStream(DataStream&, serialize_tests::OtherParam const&)
Line
Count
Source
1181
1
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>::ParamsStream(ParamsStream<DataStream&, serialize_tests::OtherParam>&&, serialize_tests::OtherParam const&)
Line
Count
Source
1181
1
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::ParamsStream(ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>&&, serialize_tests::BaseFormat const&)
Line
Count
Source
1181
1
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>::ParamsStream(ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam const&)
Line
Count
Source
1181
2
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>::ParamsStream(serialize_tests::UncopyableStream&&, serialize_tests::BaseFormat const&)
Line
Count
Source
1181
1
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::ParamsStream(ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>&&, serialize_tests::BaseFormat const&)
Line
Count
Source
1181
1
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::ParamsStream(ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>&&, serialize_tests::BaseFormat const&)
Line
Count
Source
1181
1
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<DataStream&, serialize_tests::BaseFormat>::ParamsStream(DataStream&, serialize_tests::BaseFormat const&)
Line
Count
Source
1181
8
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>::ParamsStream(DataStream&, serialize_tests::DerivedAndBaseFormat const&)
Line
Count
Source
1181
2
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>::ParamsStream(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat const&)
Line
Count
Source
1181
2
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<VectorWriter&, CNetAddr::SerParams>::ParamsStream(VectorWriter&, CNetAddr::SerParams const&)
Line
Count
Source
1181
3.48k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::ParamsStream(HashedSourceWriter<AutoFile>&, CAddress::SerParams const&)
Line
Count
Source
1181
1.66k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::ParamsStream(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams const&)
Line
Count
Source
1181
50.3k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::ParamsStream(HashVerifier<AutoFile>&, CAddress::SerParams const&)
Line
Count
Source
1181
670
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::ParamsStream(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams const&)
Line
Count
Source
1181
20.5k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>::ParamsStream(AutoFile&, CAddress::SerParams const&)
Unexecuted instantiation: ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>::ParamsStream(ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams const&)
ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::ParamsStream(HashVerifier<DataStream>&, CAddress::SerParams const&)
Line
Count
Source
1181
2
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>::ParamsStream(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams const&)
Line
Count
Source
1181
4
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<AutoFile&, TransactionSerParams>::ParamsStream(AutoFile&, TransactionSerParams const&)
Line
Count
Source
1181
1.71k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<SpanReader, CAddress::SerParams>::ParamsStream(SpanReader&&, CAddress::SerParams const&)
Line
Count
Source
1181
3
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<DataStream&, CNetAddr::SerParams>::ParamsStream(DataStream&, CNetAddr::SerParams const&)
Line
Count
Source
1181
1.73k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>::ParamsStream(ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams const&)
Line
Count
Source
1181
18.9k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>::ParamsStream(BufferedWriter<AutoFile>&, TransactionSerParams const&)
Line
Count
Source
1181
102k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
ParamsStream<BufferedFile&, TransactionSerParams>::ParamsStream(BufferedFile&, TransactionSerParams const&)
Line
Count
Source
1181
1.91k
    ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward<SubStream>(substream)} {}
1182
1183
    template <typename NestedSubstream, typename Params1, typename Params2, typename... NestedParams>
1184
    ParamsStream(NestedSubstream&& s, const Params1& params1 LIFETIMEBOUND, const Params2& params2 LIFETIMEBOUND, const NestedParams&... params LIFETIMEBOUND)
1185
4
        : ParamsStream{::ParamsStream{std::forward<NestedSubstream>(s), params2, params...}, params1} {}
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::ParamsStream<DataStream&, serialize_tests::BaseFormat, serialize_tests::OtherParam, serialize_tests::OtherParam>(DataStream&, serialize_tests::BaseFormat const&, serialize_tests::OtherParam const&, serialize_tests::OtherParam const&)
Line
Count
Source
1185
1
        : ParamsStream{::ParamsStream{std::forward<NestedSubstream>(s), params2, params...}, params1} {}
ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>::ParamsStream<DataStream&, serialize_tests::OtherParam, serialize_tests::OtherParam>(DataStream&, serialize_tests::OtherParam const&, serialize_tests::OtherParam const&)
Line
Count
Source
1185
1
        : ParamsStream{::ParamsStream{std::forward<NestedSubstream>(s), params2, params...}, params1} {}
ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat, serialize_tests::BaseFormat, serialize_tests::BaseFormat>(serialize_tests::UncopyableStream&&, serialize_tests::BaseFormat const&, serialize_tests::BaseFormat const&, serialize_tests::BaseFormat const&)
Line
Count
Source
1185
1
        : ParamsStream{::ParamsStream{std::forward<NestedSubstream>(s), params2, params...}, params1} {}
ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat, serialize_tests::BaseFormat>(serialize_tests::UncopyableStream&&, serialize_tests::BaseFormat const&, serialize_tests::BaseFormat const&)
Line
Count
Source
1185
1
        : ParamsStream{::ParamsStream{std::forward<NestedSubstream>(s), params2, params...}, params1} {}
1186
1187
41.1M
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<SizeComputer&, TransactionSerParams>& ParamsStream<SizeComputer&, TransactionSerParams>::operator<<<unsigned int>(unsigned int const&)
Line
Count
Source
1187
7.42M
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<SizeComputer&, TransactionSerParams>& ParamsStream<SizeComputer&, TransactionSerParams>::operator<<<std::vector<CTxIn, std::allocator<CTxIn>>>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
1187
4.44M
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<SizeComputer&, TransactionSerParams>& ParamsStream<SizeComputer&, TransactionSerParams>::operator<<<std::span<unsigned char const, 32ul>>(std::span<unsigned char const, 32ul> const&)
Line
Count
Source
1187
5.89M
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<SizeComputer&, TransactionSerParams>& ParamsStream<SizeComputer&, TransactionSerParams>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
734k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<SizeComputer&, TransactionSerParams>& ParamsStream<SizeComputer&, TransactionSerParams>::operator<<<std::vector<CTxOut, std::allocator<CTxOut>>>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
1187
3.71M
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<SizeComputer&, TransactionSerParams>& ParamsStream<SizeComputer&, TransactionSerParams>::operator<<<std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
1187
954k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator<<<unsigned int>(unsigned int const&)
Line
Count
Source
1187
23
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
18
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::operator<<<Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(Wrapper<CompactSizeFormatter<true>, unsigned long const&> const&)
ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::operator<<<prevector<16u, unsigned char, unsigned int, int>>(prevector<16u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1187
18
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::operator<<<unsigned char [16]>(unsigned char const (&) [16])
Line
Count
Source
1187
5
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
34
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator<<<Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(Wrapper<CompactSizeFormatter<true>, unsigned long const&> const&)
Line
Count
Source
1187
1
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator<<<prevector<16u, unsigned char, unsigned int, int>>(prevector<16u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1187
19
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator<<<unsigned char [16]>(unsigned char const (&) [16])
Line
Count
Source
1187
8
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator<<<long>(long const&)
Line
Count
Source
1187
17
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, TransactionSerParams>& ParamsStream<DataStream&, TransactionSerParams>::operator<<<unsigned int>(unsigned int const&)
Line
Count
Source
1187
202k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, TransactionSerParams>& ParamsStream<DataStream&, TransactionSerParams>::operator<<<std::vector<CTxIn, std::allocator<CTxIn>>>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
1187
196k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, TransactionSerParams>& ParamsStream<DataStream&, TransactionSerParams>::operator<<<std::span<unsigned char const, 32ul>>(std::span<unsigned char const, 32ul> const&)
Line
Count
Source
1187
125k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, TransactionSerParams>& ParamsStream<DataStream&, TransactionSerParams>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
95.2k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, TransactionSerParams>& ParamsStream<DataStream&, TransactionSerParams>::operator<<<std::vector<CTxOut, std::allocator<CTxOut>>>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
1187
101k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, TransactionSerParams>& ParamsStream<DataStream&, TransactionSerParams>::operator<<<std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
1187
116k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<VectorWriter&, TransactionSerParams>& ParamsStream<VectorWriter&, TransactionSerParams>::operator<<<unsigned int>(unsigned int const&)
Line
Count
Source
1187
118k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<VectorWriter&, TransactionSerParams>& ParamsStream<VectorWriter&, TransactionSerParams>::operator<<<std::vector<CTxIn, std::allocator<CTxIn>>>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
1187
92.2k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<VectorWriter&, TransactionSerParams>& ParamsStream<VectorWriter&, TransactionSerParams>::operator<<<std::span<unsigned char const, 32ul>>(std::span<unsigned char const, 32ul> const&)
Line
Count
Source
1187
139k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<VectorWriter&, TransactionSerParams>& ParamsStream<VectorWriter&, TransactionSerParams>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
32.9k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<VectorWriter&, TransactionSerParams>& ParamsStream<VectorWriter&, TransactionSerParams>::operator<<<std::vector<CTxOut, std::allocator<CTxOut>>>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
1187
59.3k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<VectorWriter&, TransactionSerParams>& ParamsStream<VectorWriter&, TransactionSerParams>::operator<<<std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
1187
42.0k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<HashWriter&, TransactionSerParams>& ParamsStream<HashWriter&, TransactionSerParams>::operator<<<unsigned int>(unsigned int const&)
Line
Count
Source
1187
4.83M
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<HashWriter&, TransactionSerParams>& ParamsStream<HashWriter&, TransactionSerParams>::operator<<<std::vector<CTxIn, std::allocator<CTxIn>>>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
1187
2.81M
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<HashWriter&, TransactionSerParams>& ParamsStream<HashWriter&, TransactionSerParams>::operator<<<std::span<unsigned char const, 32ul>>(std::span<unsigned char const, 32ul> const&)
Line
Count
Source
1187
2.10M
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<HashWriter&, TransactionSerParams>& ParamsStream<HashWriter&, TransactionSerParams>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
404k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<HashWriter&, TransactionSerParams>& ParamsStream<HashWriter&, TransactionSerParams>::operator<<<std::vector<CTxOut, std::allocator<CTxOut>>>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
1187
2.41M
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<HashWriter&, TransactionSerParams>& ParamsStream<HashWriter&, TransactionSerParams>::operator<<<std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
1187
556k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<VectorWriter&, CAddress::SerParams>& ParamsStream<VectorWriter&, CAddress::SerParams>::operator<<<unsigned char>(unsigned char const&)
Unexecuted instantiation: ParamsStream<VectorWriter&, CAddress::SerParams>& ParamsStream<VectorWriter&, CAddress::SerParams>::operator<<<Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(Wrapper<CompactSizeFormatter<true>, unsigned long const&> const&)
Unexecuted instantiation: ParamsStream<VectorWriter&, CAddress::SerParams>& ParamsStream<VectorWriter&, CAddress::SerParams>::operator<<<prevector<16u, unsigned char, unsigned int, int>>(prevector<16u, unsigned char, unsigned int, int> const&)
ParamsStream<VectorWriter&, CAddress::SerParams>& ParamsStream<VectorWriter&, CAddress::SerParams>::operator<<<unsigned char [16]>(unsigned char const (&) [16])
Line
Count
Source
1187
1
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::operator<<<serialize_tests::Base>(serialize_tests::Base const&)
Line
Count
Source
1187
1
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
2
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::operator<<<std::span<char const, 18446744073709551615ul>>(std::span<char const, 18446744073709551615ul> const&)
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::operator<<<serialize_tests::OtherParamChecker>(serialize_tests::OtherParamChecker const&)
Line
Count
Source
1187
1
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::operator<<<ParamsWrapper<serialize_tests::OtherParam, serialize_tests::OtherParamChecker const>>(ParamsWrapper<serialize_tests::OtherParam, serialize_tests::OtherParamChecker const> const&)
Line
Count
Source
1187
1
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>& ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
1
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::operator<<<serialize_tests::Base>(serialize_tests::Base const&)
Line
Count
Source
1187
1
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
1
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::operator<<<std::span<char const, 18446744073709551615ul>>(std::span<char const, 18446744073709551615ul> const&)
ParamsStream<DataStream&, serialize_tests::BaseFormat>& ParamsStream<DataStream&, serialize_tests::BaseFormat>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
3
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, serialize_tests::BaseFormat>& ParamsStream<DataStream&, serialize_tests::BaseFormat>::operator<<<std::span<char const, 18446744073709551615ul>>(std::span<char const, 18446744073709551615ul> const&)
Line
Count
Source
1187
3
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
1
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>::operator<<<std::span<char const, 18446744073709551615ul>>(std::span<char const, 18446744073709551615ul> const&)
Line
Count
Source
1187
1
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>& ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>::operator<<<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
1187
2
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<VectorWriter&, CNetAddr::SerParams>& ParamsStream<VectorWriter&, CNetAddr::SerParams>::operator<<<unsigned char>(unsigned char const&)
Unexecuted instantiation: ParamsStream<VectorWriter&, CNetAddr::SerParams>& ParamsStream<VectorWriter&, CNetAddr::SerParams>::operator<<<Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(Wrapper<CompactSizeFormatter<true>, unsigned long const&> const&)
Unexecuted instantiation: ParamsStream<VectorWriter&, CNetAddr::SerParams>& ParamsStream<VectorWriter&, CNetAddr::SerParams>::operator<<<prevector<16u, unsigned char, unsigned int, int>>(prevector<16u, unsigned char, unsigned int, int> const&)
ParamsStream<VectorWriter&, CNetAddr::SerParams>& ParamsStream<VectorWriter&, CNetAddr::SerParams>::operator<<<unsigned char [16]>(unsigned char const (&) [16])
Line
Count
Source
1187
3.48k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>& ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::operator<<<unsigned int>(unsigned int const&)
Line
Count
Source
1187
50.3k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
50.3k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::operator<<<Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(Wrapper<CompactSizeFormatter<true>, unsigned long const&> const&)
ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::operator<<<prevector<16u, unsigned char, unsigned int, int>>(prevector<16u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1187
50.3k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::operator<<<unsigned char [16]>(unsigned char const (&) [16])
ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>& ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
53.5k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>& ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::operator<<<uint256>(uint256 const&)
Line
Count
Source
1187
3.25k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>& ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::operator<<<std::span<unsigned char const, 32ul>>(std::span<unsigned char const, 32ul> const&)
Line
Count
Source
1187
3.25k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>& ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::operator<<<int>(int const&)
Line
Count
Source
1187
1.72M
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>& ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::operator<<<AddrInfo>(AddrInfo const&)
Line
Count
Source
1187
50.3k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>& ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::operator<<<Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(Wrapper<CompactSizeFormatter<true>, unsigned long const&> const&)
ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>& ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::operator<<<prevector<16u, unsigned char, unsigned int, int>>(prevector<16u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1187
50.3k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>& ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::operator<<<unsigned char [16]>(unsigned char const (&) [16])
ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>& ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::operator<<<long>(long const&)
Line
Count
Source
1187
50.3k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator<<<uint256>(uint256 const&)
Line
Count
Source
1187
14
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator<<<std::span<unsigned char const, 32ul>>(std::span<unsigned char const, 32ul> const&)
Line
Count
Source
1187
14
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator<<<int>(int const&)
Line
Count
Source
1187
7.20k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator<<<AddrInfo>(AddrInfo const&)
Line
Count
Source
1187
15
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<VectorWriter&, CAddress::SerParams>& ParamsStream<VectorWriter&, CAddress::SerParams>::operator<<<unsigned int>(unsigned int const&)
Line
Count
Source
1187
18.9k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
33
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>::operator<<<Wrapper<CompactSizeFormatter<true>, unsigned long const&>>(Wrapper<CompactSizeFormatter<true>, unsigned long const&> const&)
ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>::operator<<<prevector<16u, unsigned char, unsigned int, int>>(prevector<16u, unsigned char, unsigned int, int> const&)
Line
Count
Source
1187
33
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>::operator<<<unsigned char [16]>(unsigned char const (&) [16])
Line
Count
Source
1187
18.9k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>& ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>::operator<<<std::span<unsigned char const, 32ul>>(std::span<unsigned char const, 32ul> const&)
Line
Count
Source
1187
391k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>& ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>::operator<<<unsigned int>(unsigned int const&)
Line
Count
Source
1187
307k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>& ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>::operator<<<std::vector<CTxIn, std::allocator<CTxIn>>>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
1187
270k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>& ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
117k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>& ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>::operator<<<std::vector<CTxOut, std::allocator<CTxOut>>>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
1187
153k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>& ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>::operator<<<std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
1187
141k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<AutoFile&, TransactionSerParams>& ParamsStream<AutoFile&, TransactionSerParams>::operator<<<unsigned int>(unsigned int const&)
Line
Count
Source
1187
2.42k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<AutoFile&, TransactionSerParams>& ParamsStream<AutoFile&, TransactionSerParams>::operator<<<std::vector<CTxIn, std::allocator<CTxIn>>>(std::vector<CTxIn, std::allocator<CTxIn>> const&)
Line
Count
Source
1187
2.35k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<AutoFile&, TransactionSerParams>& ParamsStream<AutoFile&, TransactionSerParams>::operator<<<std::span<unsigned char const, 32ul>>(std::span<unsigned char const, 32ul> const&)
Line
Count
Source
1187
2.38k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<AutoFile&, TransactionSerParams>& ParamsStream<AutoFile&, TransactionSerParams>::operator<<<unsigned char>(unsigned char const&)
Line
Count
Source
1187
1.14k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<AutoFile&, TransactionSerParams>& ParamsStream<AutoFile&, TransactionSerParams>::operator<<<std::vector<CTxOut, std::allocator<CTxOut>>>(std::vector<CTxOut, std::allocator<CTxOut>> const&)
Line
Count
Source
1187
1.21k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
ParamsStream<AutoFile&, TransactionSerParams>& ParamsStream<AutoFile&, TransactionSerParams>::operator<<<std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>> const&)
Line
Count
Source
1187
2.26k
    template <typename U> ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; }
1188
3.28M
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, TransactionSerParams>& ParamsStream<DataStream&, TransactionSerParams>::operator>><unsigned int&>(unsigned int&)
Line
Count
Source
1188
230k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, TransactionSerParams>& ParamsStream<DataStream&, TransactionSerParams>::operator>><std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
1188
194k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, TransactionSerParams>& ParamsStream<DataStream&, TransactionSerParams>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
79.8k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, TransactionSerParams>& ParamsStream<DataStream&, TransactionSerParams>::operator>><std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
1188
115k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, TransactionSerParams>& ParamsStream<DataStream&, TransactionSerParams>::operator>><std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
1188
94.2k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
39
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator>><Wrapper<CompactSizeFormatter<true>, unsigned long&>>(Wrapper<CompactSizeFormatter<true>, unsigned long&>&&)
Line
Count
Source
1188
32
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator>><std::span<unsigned char, 18446744073709551615ul>>(std::span<unsigned char, 18446744073709551615ul>&&)
Line
Count
Source
1188
22
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator>><unsigned char (&) [16]>(unsigned char (&) [16])
Line
Count
Source
1188
1
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<SpanReader&, CAddress::SerParams>& ParamsStream<SpanReader&, CAddress::SerParams>::operator>><unsigned int&>(unsigned int&)
Line
Count
Source
1188
7
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
3
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><Wrapper<CompactSizeFormatter<true>, unsigned long&>>(Wrapper<CompactSizeFormatter<true>, unsigned long&>&&)
Line
Count
Source
1188
3
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><std::span<unsigned char, 18446744073709551615ul>>(std::span<unsigned char, 18446744073709551615ul>&&)
Line
Count
Source
1188
3
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><unsigned char (&) [16]>(unsigned char (&) [16])
Line
Count
Source
1188
4
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<SpanReader&, TransactionSerParams>& ParamsStream<SpanReader&, TransactionSerParams>::operator>><unsigned int&>(unsigned int&)
Line
Count
Source
1188
480k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<SpanReader&, TransactionSerParams>& ParamsStream<SpanReader&, TransactionSerParams>::operator>><std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
1188
449k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<SpanReader&, TransactionSerParams>& ParamsStream<SpanReader&, TransactionSerParams>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
209k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<SpanReader&, TransactionSerParams>& ParamsStream<SpanReader&, TransactionSerParams>::operator>><std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
1188
240k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<SpanReader&, TransactionSerParams>& ParamsStream<SpanReader&, TransactionSerParams>::operator>><std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
1188
294k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::operator>><serialize_tests::Base&>(serialize_tests::Base&)
Line
Count
Source
1188
1
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
2
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::operator>><std::span<char, 18446744073709551615ul>>(std::span<char, 18446744073709551615ul>&&)
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::operator>><serialize_tests::OtherParamChecker const&>(serialize_tests::OtherParamChecker const&)
Line
Count
Source
1188
1
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::operator>><ParamsWrapper<serialize_tests::OtherParam, serialize_tests::OtherParamChecker const>>(ParamsWrapper<serialize_tests::OtherParam, serialize_tests::OtherParamChecker const>&&)
Line
Count
Source
1188
1
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>& ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
1
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::operator>><serialize_tests::Base&>(serialize_tests::Base&)
Line
Count
Source
1188
1
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
1
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>& ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::operator>><std::span<char, 18446744073709551615ul>>(std::span<char, 18446744073709551615ul>&&)
ParamsStream<DataStream&, serialize_tests::BaseFormat>& ParamsStream<DataStream&, serialize_tests::BaseFormat>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
3
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, serialize_tests::BaseFormat>& ParamsStream<DataStream&, serialize_tests::BaseFormat>::operator>><std::span<char, 18446744073709551615ul>>(std::span<char, 18446744073709551615ul>&&)
Line
Count
Source
1188
3
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>& ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>::operator>><std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>& ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::operator>><unsigned int&>(unsigned int&)
Line
Count
Source
1188
20.5k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
20.5k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><Wrapper<CompactSizeFormatter<true>, unsigned long&>>(Wrapper<CompactSizeFormatter<true>, unsigned long&>&&)
Line
Count
Source
1188
20.5k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><std::span<unsigned char, 18446744073709551615ul>>(std::span<unsigned char, 18446744073709551615ul>&&)
Line
Count
Source
1188
20.5k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><unsigned char (&) [16]>(unsigned char (&) [16])
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>& ParamsStream<AutoFile&, CAddress::SerParams>::operator>><unsigned char&>(unsigned char&)
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>& ParamsStream<AutoFile&, CAddress::SerParams>::operator>><uint256&>(uint256&)
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>& ParamsStream<AutoFile&, CAddress::SerParams>::operator>><int&>(int&)
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>& ParamsStream<AutoFile&, CAddress::SerParams>::operator>><AddrInfo&>(AddrInfo&)
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>& ParamsStream<AutoFile&, CAddress::SerParams>::operator>><unsigned int&>(unsigned int&)
Unexecuted instantiation: ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><unsigned char&>(unsigned char&)
Unexecuted instantiation: ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><Wrapper<CompactSizeFormatter<true>, unsigned long&>>(Wrapper<CompactSizeFormatter<true>, unsigned long&>&&)
Unexecuted instantiation: ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><std::span<unsigned char, 18446744073709551615ul>>(std::span<unsigned char, 18446744073709551615ul>&&)
Unexecuted instantiation: ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><unsigned char (&) [16]>(unsigned char (&) [16])
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>& ParamsStream<AutoFile&, CAddress::SerParams>::operator>><Wrapper<CompactSizeFormatter<true>, unsigned long&>>(Wrapper<CompactSizeFormatter<true>, unsigned long&>&&)
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>& ParamsStream<AutoFile&, CAddress::SerParams>::operator>><std::span<unsigned char, 18446744073709551615ul>>(std::span<unsigned char, 18446744073709551615ul>&&)
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>& ParamsStream<AutoFile&, CAddress::SerParams>::operator>><unsigned char (&) [16]>(unsigned char (&) [16])
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>& ParamsStream<AutoFile&, CAddress::SerParams>::operator>><long&>(long&)
ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>& ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
21.1k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>& ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::operator>><uint256&>(uint256&)
Line
Count
Source
1188
1.26k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>& ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::operator>><int&>(int&)
Line
Count
Source
1188
670k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>& ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::operator>><AddrInfo&>(AddrInfo&)
Line
Count
Source
1188
20.5k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>& ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::operator>><Wrapper<CompactSizeFormatter<true>, unsigned long&>>(Wrapper<CompactSizeFormatter<true>, unsigned long&>&&)
Line
Count
Source
1188
20.5k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>& ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::operator>><std::span<unsigned char, 18446744073709551615ul>>(std::span<unsigned char, 18446744073709551615ul>&&)
Line
Count
Source
1188
20.5k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>& ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::operator>><unsigned char (&) [16]>(unsigned char (&) [16])
ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>& ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::operator>><long&>(long&)
Line
Count
Source
1188
20.5k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator>><uint256&>(uint256&)
Line
Count
Source
1188
13
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator>><int&>(int&)
Line
Count
Source
1188
6.17k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator>><AddrInfo&>(AddrInfo&)
Line
Count
Source
1188
14
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator>><unsigned int&>(unsigned int&)
Line
Count
Source
1188
6.91k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
1.03k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><Wrapper<CompactSizeFormatter<true>, unsigned long&>>(Wrapper<CompactSizeFormatter<true>, unsigned long&>&&)
Line
Count
Source
1188
1.03k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><std::span<unsigned char, 18446744073709551615ul>>(std::span<unsigned char, 18446744073709551615ul>&&)
Line
Count
Source
1188
1.03k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><unsigned char (&) [16]>(unsigned char (&) [16])
Line
Count
Source
1188
5.88k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<DataStream&, CAddress::SerParams>& ParamsStream<DataStream&, CAddress::SerParams>::operator>><long&>(long&)
Line
Count
Source
1188
13
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>& ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
5
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>& ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::operator>><uint256&>(uint256&)
Line
Count
Source
1188
3
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>& ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::operator>><int&>(int&)
Line
Count
Source
1188
1.03k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>& ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::operator>><AddrInfo&>(AddrInfo&)
Line
Count
Source
1188
5
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>& ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::operator>><unsigned int&>(unsigned int&)
Line
Count
Source
1188
4
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
3
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><Wrapper<CompactSizeFormatter<true>, unsigned long&>>(Wrapper<CompactSizeFormatter<true>, unsigned long&>&&)
Line
Count
Source
1188
3
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><std::span<unsigned char, 18446744073709551615ul>>(std::span<unsigned char, 18446744073709551615ul>&&)
Line
Count
Source
1188
3
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>& ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>::operator>><unsigned char (&) [16]>(unsigned char (&) [16])
Line
Count
Source
1188
1
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>& ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::operator>><Wrapper<CompactSizeFormatter<true>, unsigned long&>>(Wrapper<CompactSizeFormatter<true>, unsigned long&>&&)
Line
Count
Source
1188
3
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>& ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::operator>><std::span<unsigned char, 18446744073709551615ul>>(std::span<unsigned char, 18446744073709551615ul>&&)
Line
Count
Source
1188
3
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>& ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::operator>><unsigned char (&) [16]>(unsigned char (&) [16])
Line
Count
Source
1188
1
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>& ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::operator>><long&>(long&)
Line
Count
Source
1188
4
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<AutoFile&, TransactionSerParams>& ParamsStream<AutoFile&, TransactionSerParams>::operator>><unsigned int&>(unsigned int&)
Line
Count
Source
1188
1.00k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<AutoFile&, TransactionSerParams>& ParamsStream<AutoFile&, TransactionSerParams>::operator>><std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
1188
972
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<AutoFile&, TransactionSerParams>& ParamsStream<AutoFile&, TransactionSerParams>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
472
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<AutoFile&, TransactionSerParams>& ParamsStream<AutoFile&, TransactionSerParams>::operator>><std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
1188
500
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<AutoFile&, TransactionSerParams>& ParamsStream<AutoFile&, TransactionSerParams>::operator>><std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
1188
489
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
Unexecuted instantiation: ParamsStream<SpanReader, CAddress::SerParams>& ParamsStream<SpanReader, CAddress::SerParams>::operator>><CService&>(CService&)
Unexecuted instantiation: ParamsStream<SpanReader, CAddress::SerParams>& ParamsStream<SpanReader, CAddress::SerParams>::operator>><unsigned char&>(unsigned char&)
Unexecuted instantiation: ParamsStream<SpanReader, CAddress::SerParams>& ParamsStream<SpanReader, CAddress::SerParams>::operator>><Wrapper<CompactSizeFormatter<true>, unsigned long&>>(Wrapper<CompactSizeFormatter<true>, unsigned long&>&&)
Unexecuted instantiation: ParamsStream<SpanReader, CAddress::SerParams>& ParamsStream<SpanReader, CAddress::SerParams>::operator>><std::span<unsigned char, 18446744073709551615ul>>(std::span<unsigned char, 18446744073709551615ul>&&)
Unexecuted instantiation: ParamsStream<SpanReader, CAddress::SerParams>& ParamsStream<SpanReader, CAddress::SerParams>::operator>><unsigned char (&) [16]>(unsigned char (&) [16])
Unexecuted instantiation: ParamsStream<DataStream&, CNetAddr::SerParams>& ParamsStream<DataStream&, CNetAddr::SerParams>::operator>><unsigned char&>(unsigned char&)
Unexecuted instantiation: ParamsStream<DataStream&, CNetAddr::SerParams>& ParamsStream<DataStream&, CNetAddr::SerParams>::operator>><Wrapper<CompactSizeFormatter<true>, unsigned long&>>(Wrapper<CompactSizeFormatter<true>, unsigned long&>&&)
Unexecuted instantiation: ParamsStream<DataStream&, CNetAddr::SerParams>& ParamsStream<DataStream&, CNetAddr::SerParams>::operator>><std::span<unsigned char, 18446744073709551615ul>>(std::span<unsigned char, 18446744073709551615ul>&&)
ParamsStream<DataStream&, CNetAddr::SerParams>& ParamsStream<DataStream&, CNetAddr::SerParams>::operator>><unsigned char (&) [16]>(unsigned char (&) [16])
Line
Count
Source
1188
1.73k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<BufferedFile&, TransactionSerParams>& ParamsStream<BufferedFile&, TransactionSerParams>::operator>><unsigned int&>(unsigned int&)
Line
Count
Source
1188
4.02k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<BufferedFile&, TransactionSerParams>& ParamsStream<BufferedFile&, TransactionSerParams>::operator>><std::vector<CTxIn, std::allocator<CTxIn>>&>(std::vector<CTxIn, std::allocator<CTxIn>>&)
Line
Count
Source
1188
3.98k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<BufferedFile&, TransactionSerParams>& ParamsStream<BufferedFile&, TransactionSerParams>::operator>><unsigned char&>(unsigned char&)
Line
Count
Source
1188
1.97k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<BufferedFile&, TransactionSerParams>& ParamsStream<BufferedFile&, TransactionSerParams>::operator>><std::vector<CTxOut, std::allocator<CTxOut>>&>(std::vector<CTxOut, std::allocator<CTxOut>>&)
Line
Count
Source
1188
2.01k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
ParamsStream<BufferedFile&, TransactionSerParams>& ParamsStream<BufferedFile&, TransactionSerParams>::operator>><std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&>(std::vector<std::vector<unsigned char, std::allocator<unsigned char>>, std::allocator<std::vector<unsigned char, std::allocator<unsigned char>>>>&)
Line
Count
Source
1188
1.97k
    template <typename U> ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; }
1189
117M
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<SizeComputer&, TransactionSerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
70.7M
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<DataStream&, CAddress::SerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
7.39k
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
82
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<DataStream&, TransactionSerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
2.55M
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<VectorWriter&, TransactionSerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
1.60M
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<HashWriter&, TransactionSerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
35.2M
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<VectorWriter&, CAddress::SerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
38.1k
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
2
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
1
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
1
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<DataStream&, serialize_tests::BaseFormat>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
8
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
2
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
4
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<VectorWriter&, CNetAddr::SerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
6.96k
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
2.13M
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
201k
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
38.0k
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
4.89M
    void write(std::span<const std::byte> src) { GetStream().write(src); }
ParamsStream<AutoFile&, TransactionSerParams>::write(std::span<std::byte const, 18446744073709551615ul>)
Line
Count
Source
1189
34.1k
    void write(std::span<const std::byte> src) { GetStream().write(src); }
1190
11.8M
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<DataStream&, TransactionSerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
2.82M
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<DataStream&, CAddress::SerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
20.2k
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<SpanReader&, CAddress::SerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
18
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
20
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<SpanReader&, TransactionSerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
8.04M
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
2
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
1
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
1
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<DataStream&, serialize_tests::BaseFormat>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
8
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
Unexecuted instantiation: ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>::read(std::span<std::byte, 18446744073709551615ul>)
ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
836k
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
82.1k
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Unexecuted instantiation: ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>::read(std::span<std::byte, 18446744073709551615ul>)
ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
15.9k
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
1.06k
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
14
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<AutoFile&, TransactionSerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
9.99k
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
Unexecuted instantiation: ParamsStream<SpanReader, CAddress::SerParams>::read(std::span<std::byte, 18446744073709551615ul>)
ParamsStream<DataStream&, CNetAddr::SerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
3.46k
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
ParamsStream<BufferedFile&, TransactionSerParams>::read(std::span<std::byte, 18446744073709551615ul>)
Line
Count
Source
1190
53.3k
    void read(std::span<std::byte> dst) { GetStream().read(dst); }
1191
4
    void ignore(size_t num) { GetStream().ignore(num); }
ParamsStream<DataStream&, CAddress::SerParams>::ignore(unsigned long)
Line
Count
Source
1191
3
    void ignore(size_t num) { GetStream().ignore(num); }
Unexecuted instantiation: ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>::ignore(unsigned long)
Unexecuted instantiation: ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::ignore(unsigned long)
Unexecuted instantiation: ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>::ignore(unsigned long)
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>::ignore(unsigned long)
Unexecuted instantiation: ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::ignore(unsigned long)
ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::ignore(unsigned long)
Line
Count
Source
1191
1
    void ignore(size_t num) { GetStream().ignore(num); }
Unexecuted instantiation: ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>::ignore(unsigned long)
Unexecuted instantiation: ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::ignore(unsigned long)
Unexecuted instantiation: ParamsStream<SpanReader, CAddress::SerParams>::ignore(unsigned long)
Unexecuted instantiation: ParamsStream<DataStream&, CNetAddr::SerParams>::ignore(unsigned long)
1192
3
    bool empty() const { return GetStream().empty(); }
1193
    size_t size() const { return GetStream().size(); }
1194
1195
    //! Get reference to stream parameters.
1196
    template <typename P>
1197
    const auto& GetParams() const
1198
7.06M
    {
1199
7.06M
        if constexpr (std::is_convertible_v<Params, P>) {
1200
7.06M
            return m_params;
1201
7.06M
        } else {
1202
2
            return m_substream.template GetParams<P>();
1203
2
        }
1204
7.06M
    }
auto const& ParamsStream<SizeComputer&, TransactionSerParams>::GetParams<TransactionSerParams>() const
Line
Count
Source
1198
3.71M
    {
1199
3.71M
        if constexpr (std::is_convertible_v<Params, P>) {
1200
3.71M
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
3.71M
    }
auto const& ParamsStream<DataStream&, CAddress::SerParams>::GetParams<CAddress::SerParams>() const
Line
Count
Source
1198
6.94k
    {
1199
6.94k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
6.94k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
6.94k
    }
auto const& ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
6.94k
    {
1199
6.94k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
6.94k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
6.94k
    }
auto const& ParamsStream<DataStream&, CAddress::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
60
    {
1199
60
        if constexpr (std::is_convertible_v<Params, P>) {
1200
60
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
60
    }
auto const& ParamsStream<DataStream&, TransactionSerParams>::GetParams<TransactionSerParams>() const
Line
Count
Source
1198
216k
    {
1199
216k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
216k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
216k
    }
auto const& ParamsStream<VectorWriter&, TransactionSerParams>::GetParams<TransactionSerParams>() const
Line
Count
Source
1198
59.3k
    {
1199
59.3k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
59.3k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
59.3k
    }
auto const& ParamsStream<HashWriter&, TransactionSerParams>::GetParams<TransactionSerParams>() const
Line
Count
Source
1198
2.41M
    {
1199
2.41M
        if constexpr (std::is_convertible_v<Params, P>) {
1200
2.41M
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
2.41M
    }
auto const& ParamsStream<VectorWriter&, CAddress::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
1
    {
1199
1
        if constexpr (std::is_convertible_v<Params, P>) {
1200
1
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
1
    }
auto const& ParamsStream<SpanReader&, CAddress::SerParams>::GetParams<CAddress::SerParams>() const
Line
Count
Source
1198
7
    {
1199
7
        if constexpr (std::is_convertible_v<Params, P>) {
1200
7
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
7
    }
auto const& ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
7
    {
1199
7
        if constexpr (std::is_convertible_v<Params, P>) {
1200
7
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
7
    }
auto const& ParamsStream<SpanReader&, TransactionSerParams>::GetParams<TransactionSerParams>() const
Line
Count
Source
1198
240k
    {
1199
240k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
240k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
240k
    }
auto const& ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::GetParams<serialize_tests::BaseFormat>() const
Line
Count
Source
1198
2
    {
1199
2
        if constexpr (std::is_convertible_v<Params, P>) {
1200
2
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
2
    }
auto const& ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::GetParams<serialize_tests::OtherParam>() const
Line
Count
Source
1198
2
    {
1199
        if constexpr (std::is_convertible_v<Params, P>) {
1200
            return m_params;
1201
2
        } else {
1202
2
            return m_substream.template GetParams<P>();
1203
2
        }
1204
2
    }
auto const& ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>::GetParams<serialize_tests::OtherParam>() const
Line
Count
Source
1198
2
    {
1199
2
        if constexpr (std::is_convertible_v<Params, P>) {
1200
2
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
2
    }
auto const& ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>::GetParams<serialize_tests::OtherParam>() const
Line
Count
Source
1198
2
    {
1199
2
        if constexpr (std::is_convertible_v<Params, P>) {
1200
2
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
2
    }
auto const& ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::GetParams<serialize_tests::BaseFormat>() const
Line
Count
Source
1198
2
    {
1199
2
        if constexpr (std::is_convertible_v<Params, P>) {
1200
2
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
2
    }
auto const& ParamsStream<DataStream&, serialize_tests::BaseFormat>::GetParams<serialize_tests::BaseFormat>() const
Line
Count
Source
1198
12
    {
1199
12
        if constexpr (std::is_convertible_v<Params, P>) {
1200
12
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
12
    }
auto const& ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>::GetParams<serialize_tests::DerivedAndBaseFormat>() const
Line
Count
Source
1198
2
    {
1199
2
        if constexpr (std::is_convertible_v<Params, P>) {
1200
2
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
2
    }
auto const& ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>::GetParams<serialize_tests::BaseFormat>() const
Line
Count
Source
1198
2
    {
1199
2
        if constexpr (std::is_convertible_v<Params, P>) {
1200
2
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
2
    }
auto const& ParamsStream<VectorWriter&, CNetAddr::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
3.48k
    {
1199
3.48k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
3.48k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
3.48k
    }
auto const& ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::GetParams<CAddress::SerParams>() const
Line
Count
Source
1198
50.3k
    {
1199
50.3k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
50.3k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
50.3k
    }
auto const& ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
50.3k
    {
1199
50.3k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
50.3k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
50.3k
    }
auto const& ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::GetParams<CAddress::SerParams>() const
Line
Count
Source
1198
20.5k
    {
1199
20.5k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
20.5k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
20.5k
    }
auto const& ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
20.5k
    {
1199
20.5k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
20.5k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
20.5k
    }
auto const& ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
50.3k
    {
1199
50.3k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
50.3k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
50.3k
    }
Unexecuted instantiation: auto const& ParamsStream<AutoFile&, CAddress::SerParams>::GetParams<CAddress::SerParams>() const
Unexecuted instantiation: auto const& ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>::GetParams<CNetAddr::SerParams>() const
Unexecuted instantiation: auto const& ParamsStream<AutoFile&, CAddress::SerParams>::GetParams<CNetAddr::SerParams>() const
auto const& ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
20.5k
    {
1199
20.5k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
20.5k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
20.5k
    }
auto const& ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::GetParams<CAddress::SerParams>() const
Line
Count
Source
1198
5
    {
1199
5
        if constexpr (std::is_convertible_v<Params, P>) {
1200
5
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
5
    }
auto const& ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
4
    {
1199
4
        if constexpr (std::is_convertible_v<Params, P>) {
1200
4
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
4
    }
auto const& ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
4
    {
1199
4
        if constexpr (std::is_convertible_v<Params, P>) {
1200
4
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
4
    }
auto const& ParamsStream<AutoFile&, TransactionSerParams>::GetParams<TransactionSerParams>() const
Line
Count
Source
1198
1.71k
    {
1199
1.71k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
1.71k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
1.71k
    }
Unexecuted instantiation: auto const& ParamsStream<SpanReader, CAddress::SerParams>::GetParams<CNetAddr::SerParams>() const
auto const& ParamsStream<DataStream&, CNetAddr::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
1.73k
    {
1199
1.73k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
1.73k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
1.73k
    }
auto const& ParamsStream<VectorWriter&, CAddress::SerParams>::GetParams<CAddress::SerParams>() const
Line
Count
Source
1198
18.9k
    {
1199
18.9k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
18.9k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
18.9k
    }
auto const& ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>::GetParams<CNetAddr::SerParams>() const
Line
Count
Source
1198
18.9k
    {
1199
18.9k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
18.9k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
18.9k
    }
auto const& ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>::GetParams<TransactionSerParams>() const
Line
Count
Source
1198
153k
    {
1199
153k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
153k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
153k
    }
auto const& ParamsStream<BufferedFile&, TransactionSerParams>::GetParams<TransactionSerParams>() const
Line
Count
Source
1198
2.01k
    {
1199
2.01k
        if constexpr (std::is_convertible_v<Params, P>) {
1200
2.01k
            return m_params;
1201
        } else {
1202
            return m_substream.template GetParams<P>();
1203
        }
1204
2.01k
    }
1205
1206
    //! Get reference to underlying stream.
1207
    auto& GetStream()
1208
129M
    {
1209
129M
        if constexpr (ContainsStream<SubStream>) {
1210
337k
            return m_substream.GetStream();
1211
129M
        } else {
1212
129M
            return m_substream;
1213
129M
        }
1214
129M
    }
ParamsStream<SizeComputer&, TransactionSerParams>::GetStream()
Line
Count
Source
1208
70.7M
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
70.7M
        } else {
1212
70.7M
            return m_substream;
1213
70.7M
        }
1214
70.7M
    }
ParamsStream<DataStream&, CAddress::SerParams>::GetStream()
Line
Count
Source
1208
43.6k
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
43.6k
        } else {
1212
43.6k
            return m_substream;
1213
43.6k
        }
1214
43.6k
    }
ParamsStream<ParamsStream<DataStream&, CAddress::SerParams>&, CNetAddr::SerParams>::GetStream()
Line
Count
Source
1208
15.9k
    {
1209
15.9k
        if constexpr (ContainsStream<SubStream>) {
1210
15.9k
            return m_substream.GetStream();
1211
        } else {
1212
            return m_substream;
1213
        }
1214
15.9k
    }
ParamsStream<DataStream&, TransactionSerParams>::GetStream()
Line
Count
Source
1208
5.37M
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
5.37M
        } else {
1212
5.37M
            return m_substream;
1213
5.37M
        }
1214
5.37M
    }
ParamsStream<VectorWriter&, TransactionSerParams>::GetStream()
Line
Count
Source
1208
1.60M
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
1.60M
        } else {
1212
1.60M
            return m_substream;
1213
1.60M
        }
1214
1.60M
    }
ParamsStream<HashWriter&, TransactionSerParams>::GetStream()
Line
Count
Source
1208
35.2M
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
35.2M
        } else {
1212
35.2M
            return m_substream;
1213
35.2M
        }
1214
35.2M
    }
ParamsStream<VectorWriter&, CAddress::SerParams>::GetStream()
Line
Count
Source
1208
76.2k
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
76.2k
        } else {
1212
76.2k
            return m_substream;
1213
76.2k
        }
1214
76.2k
    }
ParamsStream<SpanReader&, CAddress::SerParams>::GetStream()
Line
Count
Source
1208
38
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
38
        } else {
1212
38
            return m_substream;
1213
38
        }
1214
38
    }
ParamsStream<ParamsStream<SpanReader&, CAddress::SerParams>&, CNetAddr::SerParams>::GetStream()
Line
Count
Source
1208
20
    {
1209
20
        if constexpr (ContainsStream<SubStream>) {
1210
20
            return m_substream.GetStream();
1211
        } else {
1212
            return m_substream;
1213
        }
1214
20
    }
ParamsStream<SpanReader&, TransactionSerParams>::GetStream()
Line
Count
Source
1208
8.04M
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
8.04M
        } else {
1212
8.04M
            return m_substream;
1213
8.04M
        }
1214
8.04M
    }
ParamsStream<ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::GetStream()
Line
Count
Source
1208
5
    {
1209
5
        if constexpr (ContainsStream<SubStream>) {
1210
5
            return m_substream.GetStream();
1211
        } else {
1212
            return m_substream;
1213
        }
1214
5
    }
ParamsStream<ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>, serialize_tests::BaseFormat>::GetStream()
Line
Count
Source
1208
5
    {
1209
5
        if constexpr (ContainsStream<SubStream>) {
1210
5
            return m_substream.GetStream();
1211
        } else {
1212
            return m_substream;
1213
        }
1214
5
    }
ParamsStream<serialize_tests::UncopyableStream, serialize_tests::BaseFormat>::GetStream()
Line
Count
Source
1208
5
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
5
        } else {
1212
5
            return m_substream;
1213
5
        }
1214
5
    }
ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>::GetStream()
Line
Count
Source
1208
6
    {
1209
6
        if constexpr (ContainsStream<SubStream>) {
1210
6
            return m_substream.GetStream();
1211
        } else {
1212
            return m_substream;
1213
        }
1214
6
    }
ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>::GetStream()
Line
Count
Source
1208
6
    {
1209
6
        if constexpr (ContainsStream<SubStream>) {
1210
6
            return m_substream.GetStream();
1211
        } else {
1212
            return m_substream;
1213
        }
1214
6
    }
ParamsStream<DataStream&, serialize_tests::OtherParam>::GetStream()
Line
Count
Source
1208
6
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
6
        } else {
1212
6
            return m_substream;
1213
6
        }
1214
6
    }
ParamsStream<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&, serialize_tests::OtherParam>::GetStream()
Line
Count
Source
1208
2
    {
1209
2
        if constexpr (ContainsStream<SubStream>) {
1210
2
            return m_substream.GetStream();
1211
        } else {
1212
            return m_substream;
1213
        }
1214
2
    }
ParamsStream<DataStream&, serialize_tests::BaseFormat>::GetStream()
Line
Count
Source
1208
16
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
16
        } else {
1212
16
            return m_substream;
1213
16
        }
1214
16
    }
ParamsStream<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&, serialize_tests::BaseFormat>::GetStream()
Line
Count
Source
1208
2
    {
1209
2
        if constexpr (ContainsStream<SubStream>) {
1210
2
            return m_substream.GetStream();
1211
        } else {
1212
            return m_substream;
1213
        }
1214
2
    }
ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>::GetStream()
Line
Count
Source
1208
6
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
6
        } else {
1212
6
            return m_substream;
1213
6
        }
1214
6
    }
ParamsStream<VectorWriter&, CNetAddr::SerParams>::GetStream()
Line
Count
Source
1208
6.96k
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
6.96k
        } else {
1212
6.96k
            return m_substream;
1213
6.96k
        }
1214
6.96k
    }
ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>::GetStream()
Line
Count
Source
1208
2.33M
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
2.33M
        } else {
1212
2.33M
            return m_substream;
1213
2.33M
        }
1214
2.33M
    }
ParamsStream<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::GetStream()
Line
Count
Source
1208
201k
    {
1209
201k
        if constexpr (ContainsStream<SubStream>) {
1210
201k
            return m_substream.GetStream();
1211
        } else {
1212
            return m_substream;
1213
        }
1214
201k
    }
ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>::GetStream()
Line
Count
Source
1208
919k
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
919k
        } else {
1212
919k
            return m_substream;
1213
919k
        }
1214
919k
    }
ParamsStream<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&, CNetAddr::SerParams>::GetStream()
Line
Count
Source
1208
82.1k
    {
1209
82.1k
        if constexpr (ContainsStream<SubStream>) {
1210
82.1k
            return m_substream.GetStream();
1211
        } else {
1212
            return m_substream;
1213
        }
1214
82.1k
    }
Unexecuted instantiation: ParamsStream<AutoFile&, CAddress::SerParams>::GetStream()
Unexecuted instantiation: ParamsStream<ParamsStream<AutoFile&, CAddress::SerParams>&, CNetAddr::SerParams>::GetStream()
ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>::GetStream()
Line
Count
Source
1208
1.08k
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
1.08k
        } else {
1212
1.08k
            return m_substream;
1213
1.08k
        }
1214
1.08k
    }
ParamsStream<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&, CNetAddr::SerParams>::GetStream()
Line
Count
Source
1208
14
    {
1209
14
        if constexpr (ContainsStream<SubStream>) {
1210
14
            return m_substream.GetStream();
1211
        } else {
1212
            return m_substream;
1213
        }
1214
14
    }
ParamsStream<AutoFile&, TransactionSerParams>::GetStream()
Line
Count
Source
1208
44.1k
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
44.1k
        } else {
1212
44.1k
            return m_substream;
1213
44.1k
        }
1214
44.1k
    }
Unexecuted instantiation: ParamsStream<SpanReader, CAddress::SerParams>::GetStream()
ParamsStream<DataStream&, CNetAddr::SerParams>::GetStream()
Line
Count
Source
1208
3.46k
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
3.46k
        } else {
1212
3.46k
            return m_substream;
1213
3.46k
        }
1214
3.46k
    }
ParamsStream<ParamsStream<VectorWriter&, CAddress::SerParams>&, CNetAddr::SerParams>::GetStream()
Line
Count
Source
1208
38.0k
    {
1209
38.0k
        if constexpr (ContainsStream<SubStream>) {
1210
38.0k
            return m_substream.GetStream();
1211
        } else {
1212
            return m_substream;
1213
        }
1214
38.0k
    }
ParamsStream<BufferedWriter<AutoFile>&, TransactionSerParams>::GetStream()
Line
Count
Source
1208
4.89M
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
4.89M
        } else {
1212
4.89M
            return m_substream;
1213
4.89M
        }
1214
4.89M
    }
ParamsStream<BufferedFile&, TransactionSerParams>::GetStream()
Line
Count
Source
1208
53.3k
    {
1209
        if constexpr (ContainsStream<SubStream>) {
1210
            return m_substream.GetStream();
1211
53.3k
        } else {
1212
53.3k
            return m_substream;
1213
53.3k
        }
1214
53.3k
    }
1215
    const auto& GetStream() const
1216
3
    {
1217
        if constexpr (ContainsStream<SubStream>) {
1218
            return m_substream.GetStream();
1219
3
        } else {
1220
3
            return m_substream;
1221
3
        }
1222
3
    }
1223
};
1224
1225
/**
1226
 * Explicit template deduction guide is required for single-parameter
1227
 * constructor so Substream&& is treated as a forwarding reference, and
1228
 * SubStream is deduced as reference type for lvalue arguments.
1229
 */
1230
template <typename Substream, typename Params>
1231
ParamsStream(Substream&&, const Params&) -> ParamsStream<Substream, Params>;
1232
1233
/**
1234
 * Template deduction guide for multiple params arguments that creates a nested
1235
 * ParamsStream.
1236
 */
1237
template <typename Substream, typename Params1, typename Params2, typename... Params>
1238
ParamsStream(Substream&& s, const Params1& params1, const Params2& params2, const Params&... params) ->
1239
    ParamsStream<decltype(ParamsStream{std::forward<Substream>(s), params2, params...}), Params1>;
1240
1241
/** Wrapper that serializes objects with the specified parameters. */
1242
template <typename Params, typename T>
1243
class ParamsWrapper
1244
{
1245
    const Params& m_params;
1246
    T& m_object;
1247
1248
public:
1249
6.37M
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<CNetAddr::SerParams, CService const>::ParamsWrapper(CNetAddr::SerParams const&, CService const&)
Line
Count
Source
1249
69.3k
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<CAddress::SerParams, AddrInfo>::ParamsWrapper(CAddress::SerParams const&, AddrInfo&)
Line
Count
Source
1249
2
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>>::ParamsWrapper(TransactionSerParams const&, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>&)
Line
Count
Source
1249
21.6k
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>::ParamsWrapper(TransactionSerParams const&, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>&)
Line
Count
Source
1249
54.5k
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, CBlock const>::ParamsWrapper(TransactionSerParams const&, CBlock const&)
Line
Count
Source
1249
821k
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, CBlock>::ParamsWrapper(TransactionSerParams const&, CBlock&)
Line
Count
Source
1249
176k
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, CTransaction const>::ParamsWrapper(TransactionSerParams const&, CTransaction const&)
Line
Count
Source
1249
4.35M
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, CMutableTransaction>::ParamsWrapper(TransactionSerParams const&, CMutableTransaction&)
Line
Count
Source
1249
96.9k
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<CAddress::SerParams, CNetAddr>::ParamsWrapper(CAddress::SerParams const&, CNetAddr&)
Line
Count
Source
1249
30
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<CAddress::SerParams, CService const>::ParamsWrapper(CAddress::SerParams const&, CService const&)
Line
Count
Source
1249
1
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<CNetAddr::SerParams, CService>::ParamsWrapper(CNetAddr::SerParams const&, CService&)
Line
Count
Source
1249
32.6k
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>>>::ParamsWrapper(CAddress::SerParams const&, std::vector<CAddress, std::allocator<CAddress>>&)
Line
Count
Source
1249
234
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>> const>::ParamsWrapper(CAddress::SerParams const&, std::vector<CAddress, std::allocator<CAddress>> const&)
Line
Count
Source
1249
41
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<serialize_tests::OtherParam, serialize_tests::OtherParamChecker const>::ParamsWrapper(serialize_tests::OtherParam const&, serialize_tests::OtherParamChecker const&)
Line
Count
Source
1249
2
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<serialize_tests::BaseFormat, serialize_tests::Base>::ParamsWrapper(serialize_tests::BaseFormat const&, serialize_tests::Base&)
Line
Count
Source
1249
4
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<serialize_tests::BaseFormat, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>>::ParamsWrapper(serialize_tests::BaseFormat const&, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>&)
Line
Count
Source
1249
4
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<serialize_tests::DerivedAndBaseFormat, serialize_tests::Derived>::ParamsWrapper(serialize_tests::DerivedAndBaseFormat const&, serialize_tests::Derived&)
Line
Count
Source
1249
2
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const>::ParamsWrapper(TransactionSerParams const&, std::shared_ptr<CTransaction const> const&)
Line
Count
Source
1249
18.8k
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>::ParamsWrapper(TransactionSerParams const&, std::shared_ptr<CTransaction const>&)
Line
Count
Source
1249
61.9k
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<serialize_tests::BaseFormat, serialize_tests::Base const>::ParamsWrapper(serialize_tests::BaseFormat const&, serialize_tests::Base const&)
Line
Count
Source
1249
2
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, CTransaction>::ParamsWrapper(TransactionSerParams const&, CTransaction&)
Line
Count
Source
1249
1
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, CTxIn const>::ParamsWrapper(TransactionSerParams const&, CTxIn const&)
Line
Count
Source
1249
4.99k
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>>::ParamsWrapper(TransactionSerParams const&, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>&)
Line
Count
Source
1249
590
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, std::vector<CBlock, std::allocator<CBlock>>>::ParamsWrapper(TransactionSerParams const&, std::vector<CBlock, std::allocator<CBlock>>&)
Line
Count
Source
1249
5.27k
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>>::ParamsWrapper(TransactionSerParams const&, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>&)
Line
Count
Source
1249
572
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
ParamsWrapper<TransactionSerParams, CMutableTransaction const>::ParamsWrapper(TransactionSerParams const&, CMutableTransaction const&)
Line
Count
Source
1249
661k
    explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {}
1250
1251
    template <typename Stream>
1252
    void Serialize(Stream& s) const
1253
6.06M
    {
1254
6.06M
        ParamsStream ss{s, m_params};
1255
6.06M
        ::Serialize(ss, m_object);
1256
6.06M
    }
void ParamsWrapper<TransactionSerParams, CTransaction const>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
1253
2.57M
    {
1254
2.57M
        ParamsStream ss{s, m_params};
1255
2.57M
        ::Serialize(ss, m_object);
1256
2.57M
    }
void ParamsWrapper<TransactionSerParams, CBlock const>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
1253
710k
    {
1254
710k
        ParamsStream ss{s, m_params};
1255
710k
        ::Serialize(ss, m_object);
1256
710k
    }
void ParamsWrapper<TransactionSerParams, CTxIn const>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
1253
4.99k
    {
1254
4.99k
        ParamsStream ss{s, m_params};
1255
4.99k
        ::Serialize(ss, m_object);
1256
4.99k
    }
void ParamsWrapper<CAddress::SerParams, AddrInfo>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
1253
2
    {
1254
2
        ParamsStream ss{s, m_params};
1255
2
        ::Serialize(ss, m_object);
1256
2
    }
void ParamsWrapper<CNetAddr::SerParams, CService const>::Serialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&) const
Line
Count
Source
1253
23
    {
1254
23
        ParamsStream ss{s, m_params};
1255
23
        ::Serialize(ss, m_object);
1256
23
    }
void ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
1253
11
    {
1254
11
        ParamsStream ss{s, m_params};
1255
11
        ::Serialize(ss, m_object);
1256
11
    }
void ParamsWrapper<TransactionSerParams, CTransaction const>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
1253
13.9k
    {
1254
13.9k
        ParamsStream ss{s, m_params};
1255
13.9k
        ::Serialize(ss, m_object);
1256
13.9k
    }
void ParamsWrapper<TransactionSerParams, CMutableTransaction>::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
1253
50.0k
    {
1254
50.0k
        ParamsStream ss{s, m_params};
1255
50.0k
        ::Serialize(ss, m_object);
1256
50.0k
    }
void ParamsWrapper<TransactionSerParams, CMutableTransaction>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
1253
61
    {
1254
61
        ParamsStream ss{s, m_params};
1255
61
        ::Serialize(ss, m_object);
1256
61
    }
void ParamsWrapper<CAddress::SerParams, CNetAddr>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
1253
10
    {
1254
10
        ParamsStream ss{s, m_params};
1255
10
        ::Serialize(ss, m_object);
1256
10
    }
void ParamsWrapper<CAddress::SerParams, CService const>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
1253
1
    {
1254
1
        ParamsStream ss{s, m_params};
1255
1
        ::Serialize(ss, m_object);
1256
1
    }
void ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>> const>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
1253
2
    {
1254
2
        ParamsStream ss{s, m_params};
1255
2
        ::Serialize(ss, m_object);
1256
2
    }
void ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
1253
18.8k
    {
1254
18.8k
        ParamsStream ss{s, m_params};
1255
18.8k
        ::Serialize(ss, m_object);
1256
18.8k
    }
void ParamsWrapper<TransactionSerParams, CMutableTransaction>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
1253
361
    {
1254
361
        ParamsStream ss{s, m_params};
1255
361
        ::Serialize(ss, m_object);
1256
361
    }
void ParamsWrapper<serialize_tests::OtherParam, serialize_tests::OtherParamChecker const>::Serialize<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>>(ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&) const
Line
Count
Source
1253
1
    {
1254
1
        ParamsStream ss{s, m_params};
1255
1
        ::Serialize(ss, m_object);
1256
1
    }
void ParamsWrapper<serialize_tests::BaseFormat, serialize_tests::Base>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
1253
2
    {
1254
2
        ParamsStream ss{s, m_params};
1255
2
        ::Serialize(ss, m_object);
1256
2
    }
void ParamsWrapper<serialize_tests::BaseFormat, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
1253
2
    {
1254
2
        ParamsStream ss{s, m_params};
1255
2
        ::Serialize(ss, m_object);
1256
2
    }
void ParamsWrapper<serialize_tests::DerivedAndBaseFormat, serialize_tests::Derived>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
1253
2
    {
1254
2
        ParamsStream ss{s, m_params};
1255
2
        ::Serialize(ss, m_object);
1256
2
    }
void ParamsWrapper<serialize_tests::BaseFormat, serialize_tests::Base const>::Serialize<ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>>(ParamsStream<DataStream&, serialize_tests::DerivedAndBaseFormat>&) const
Line
Count
Source
1253
2
    {
1254
2
        ParamsStream ss{s, m_params};
1255
2
        ::Serialize(ss, m_object);
1256
2
    }
void ParamsWrapper<TransactionSerParams, CTransaction>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
1253
1
    {
1254
1
        ParamsStream ss{s, m_params};
1255
1
        ::Serialize(ss, m_object);
1256
1
    }
void ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
1253
1
    {
1254
1
        ParamsStream ss{s, m_params};
1255
1
        ::Serialize(ss, m_object);
1256
1
    }
void ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const> const>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
1253
594
    {
1254
594
        ParamsStream ss{s, m_params};
1255
594
        ::Serialize(ss, m_object);
1256
594
    }
void ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
1253
24.7k
    {
1254
24.7k
        ParamsStream ss{s, m_params};
1255
24.7k
        ::Serialize(ss, m_object);
1256
24.7k
    }
void ParamsWrapper<CNetAddr::SerParams, CService>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
1253
3.48k
    {
1254
3.48k
        ParamsStream ss{s, m_params};
1255
3.48k
        ::Serialize(ss, m_object);
1256
3.48k
    }
void ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>> const>::Serialize<HashedSourceWriter<AutoFile>>(HashedSourceWriter<AutoFile>&) const
Line
Count
Source
1253
39
    {
1254
39
        ParamsStream ss{s, m_params};
1255
39
        ::Serialize(ss, m_object);
1256
39
    }
void ParamsWrapper<CNetAddr::SerParams, CService const>::Serialize<ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashedSourceWriter<AutoFile>&, CAddress::SerParams>&) const
Line
Count
Source
1253
50.3k
    {
1254
50.3k
        ParamsStream ss{s, m_params};
1255
50.3k
        ::Serialize(ss, m_object);
1256
50.3k
    }
void ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>::Serialize<SizeComputer>(SizeComputer&) const
Line
Count
Source
1253
35.7k
    {
1254
35.7k
        ParamsStream ss{s, m_params};
1255
35.7k
        ::Serialize(ss, m_object);
1256
35.7k
    }
void ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
1253
18.8k
    {
1254
18.8k
        ParamsStream ss{s, m_params};
1255
18.8k
        ::Serialize(ss, m_object);
1256
18.8k
    }
void ParamsWrapper<TransactionSerParams, CBlock const>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
1253
8.24k
    {
1254
8.24k
        ParamsStream ss{s, m_params};
1255
8.24k
        ::Serialize(ss, m_object);
1256
8.24k
    }
void ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
1253
590
    {
1254
590
        ParamsStream ss{s, m_params};
1255
590
        ::Serialize(ss, m_object);
1256
590
    }
void ParamsWrapper<TransactionSerParams, std::vector<CBlock, std::allocator<CBlock>>>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
1253
5.27k
    {
1254
5.27k
        ParamsStream ss{s, m_params};
1255
5.27k
        ::Serialize(ss, m_object);
1256
5.27k
    }
void ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>>>::Serialize<VectorWriter>(VectorWriter&) const
Line
Count
Source
1253
134
    {
1254
134
        ParamsStream ss{s, m_params};
1255
134
        ::Serialize(ss, m_object);
1256
134
    }
void ParamsWrapper<CNetAddr::SerParams, CService const>::Serialize<ParamsStream<VectorWriter&, CAddress::SerParams>>(ParamsStream<VectorWriter&, CAddress::SerParams>&) const
Line
Count
Source
1253
18.9k
    {
1254
18.9k
        ParamsStream ss{s, m_params};
1255
18.9k
        ::Serialize(ss, m_object);
1256
18.9k
    }
void ParamsWrapper<TransactionSerParams, CBlock const>::Serialize<BufferedWriter<AutoFile>>(BufferedWriter<AutoFile>&) const
Line
Count
Source
1253
102k
    {
1254
102k
        ParamsStream ss{s, m_params};
1255
102k
        ::Serialize(ss, m_object);
1256
102k
    }
void ParamsWrapper<TransactionSerParams, CTransaction const>::Serialize<AutoFile>(AutoFile&) const
Line
Count
Source
1253
1.21k
    {
1254
1.21k
        ParamsStream ss{s, m_params};
1255
1.21k
        ::Serialize(ss, m_object);
1256
1.21k
    }
void ParamsWrapper<TransactionSerParams, CBlock const>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
1253
5
    {
1254
5
        ParamsStream ss{s, m_params};
1255
5
        ::Serialize(ss, m_object);
1256
5
    }
void ParamsWrapper<TransactionSerParams, CMutableTransaction const>::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
1253
661k
    {
1254
661k
        ParamsStream ss{s, m_params};
1255
661k
        ::Serialize(ss, m_object);
1256
661k
    }
void ParamsWrapper<TransactionSerParams, CTransaction const>::Serialize<HashWriter>(HashWriter&) const
Line
Count
Source
1253
1.70M
    {
1254
1.70M
        ParamsStream ss{s, m_params};
1255
1.70M
        ::Serialize(ss, m_object);
1256
1.70M
    }
void ParamsWrapper<TransactionSerParams, CTransaction const>::Serialize<DataStream>(DataStream&) const
Line
Count
Source
1253
57.1k
    {
1254
57.1k
        ParamsStream ss{s, m_params};
1255
57.1k
        ::Serialize(ss, m_object);
1256
57.1k
    }
1257
    template <typename Stream>
1258
    void Unserialize(Stream& s)
1259
311k
    {
1260
311k
        ParamsStream ss{s, m_params};
1261
311k
        ::Unserialize(ss, m_object);
1262
311k
    }
void ParamsWrapper<TransactionSerParams, Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
1259
21.6k
    {
1260
21.6k
        ParamsStream ss{s, m_params};
1261
21.6k
        ::Unserialize(ss, m_object);
1262
21.6k
    }
void ParamsWrapper<TransactionSerParams, CBlock>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
1259
34.2k
    {
1260
34.2k
        ParamsStream ss{s, m_params};
1261
34.2k
        ::Unserialize(ss, m_object);
1262
34.2k
    }
void ParamsWrapper<CAddress::SerParams, CNetAddr>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
1259
20
    {
1260
20
        ParamsStream ss{s, m_params};
1261
20
        ::Unserialize(ss, m_object);
1262
20
    }
void ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>>>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
1259
3
    {
1260
3
        ParamsStream ss{s, m_params};
1261
3
        ::Unserialize(ss, m_object);
1262
3
    }
void ParamsWrapper<CNetAddr::SerParams, CService>::Unserialize<ParamsStream<SpanReader&, CAddress::SerParams>>(ParamsStream<SpanReader&, CAddress::SerParams>&)
Line
Count
Source
1259
7
    {
1260
7
        ParamsStream ss{s, m_params};
1261
7
        ::Unserialize(ss, m_object);
1262
7
    }
void ParamsWrapper<TransactionSerParams, CMutableTransaction>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
1259
46.5k
    {
1260
46.5k
        ParamsStream ss{s, m_params};
1261
46.5k
        ::Unserialize(ss, m_object);
1262
46.5k
    }
void ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
1259
35.7k
    {
1260
35.7k
        ParamsStream ss{s, m_params};
1261
35.7k
        ::Unserialize(ss, m_object);
1262
35.7k
    }
void ParamsWrapper<serialize_tests::OtherParam, serialize_tests::OtherParamChecker const>::Unserialize<ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>>(ParamsStream<ParamsStream<ParamsStream<DataStream&, serialize_tests::OtherParam>, serialize_tests::OtherParam>, serialize_tests::BaseFormat>&)
Line
Count
Source
1259
1
    {
1260
1
        ParamsStream ss{s, m_params};
1261
1
        ::Unserialize(ss, m_object);
1262
1
    }
void ParamsWrapper<serialize_tests::BaseFormat, serialize_tests::Base>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
1259
2
    {
1260
2
        ParamsStream ss{s, m_params};
1261
2
        ::Unserialize(ss, m_object);
1262
2
    }
void ParamsWrapper<serialize_tests::BaseFormat, std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
1259
2
    {
1260
2
        ParamsStream ss{s, m_params};
1261
2
        ::Unserialize(ss, m_object);
1262
2
    }
void ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
1259
989
    {
1260
989
        ParamsStream ss{s, m_params};
1261
989
        ::Unserialize(ss, m_object);
1262
989
    }
void ParamsWrapper<TransactionSerParams, CMutableTransaction>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
1259
25
    {
1260
25
        ParamsStream ss{s, m_params};
1261
25
        ::Unserialize(ss, m_object);
1262
25
    }
void ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>>>::Unserialize<HashVerifier<AutoFile>>(HashVerifier<AutoFile>&)
Line
Count
Source
1259
31
    {
1260
31
        ParamsStream ss{s, m_params};
1261
31
        ::Unserialize(ss, m_object);
1262
31
    }
void ParamsWrapper<CNetAddr::SerParams, CService>::Unserialize<ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>>(ParamsStream<HashVerifier<AutoFile>&, CAddress::SerParams>&)
Line
Count
Source
1259
20.5k
    {
1260
20.5k
        ParamsStream ss{s, m_params};
1261
20.5k
        ::Unserialize(ss, m_object);
1262
20.5k
    }
Unexecuted instantiation: void ParamsWrapper<CNetAddr::SerParams, CService>::Unserialize<ParamsStream<AutoFile&, CAddress::SerParams>>(ParamsStream<AutoFile&, CAddress::SerParams>&)
void ParamsWrapper<CNetAddr::SerParams, CService>::Unserialize<ParamsStream<DataStream&, CAddress::SerParams>>(ParamsStream<DataStream&, CAddress::SerParams>&)
Line
Count
Source
1259
6.91k
    {
1260
6.91k
        ParamsStream ss{s, m_params};
1261
6.91k
        ::Unserialize(ss, m_object);
1262
6.91k
    }
void ParamsWrapper<CNetAddr::SerParams, CService>::Unserialize<ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>>(ParamsStream<HashVerifier<DataStream>&, CAddress::SerParams>&)
Line
Count
Source
1259
4
    {
1260
4
        ParamsStream ss{s, m_params};
1261
4
        ::Unserialize(ss, m_object);
1262
4
    }
void ParamsWrapper<TransactionSerParams, std::shared_ptr<CTransaction const>>::Unserialize<AutoFile>(AutoFile&)
Line
Count
Source
1259
500
    {
1260
500
        ParamsStream ss{s, m_params};
1261
500
        ::Unserialize(ss, m_object);
1262
500
    }
void ParamsWrapper<CNetAddr::SerParams, CService>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
1259
1.73k
    {
1260
1.73k
        ParamsStream ss{s, m_params};
1261
1.73k
        ::Unserialize(ss, m_object);
1262
1.73k
    }
void ParamsWrapper<CAddress::SerParams, std::vector<CAddress, std::allocator<CAddress>>>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
1259
58
    {
1260
58
        ParamsStream ss{s, m_params};
1261
58
        ::Unserialize(ss, m_object);
1262
58
    }
void ParamsWrapper<TransactionSerParams, Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>>::Unserialize<DataStream>(DataStream&)
Line
Count
Source
1259
572
    {
1260
572
        ParamsStream ss{s, m_params};
1261
572
        ::Unserialize(ss, m_object);
1262
572
    }
void ParamsWrapper<TransactionSerParams, CBlock>::Unserialize<SpanReader>(SpanReader&)
Line
Count
Source
1259
139k
    {
1260
139k
        ParamsStream ss{s, m_params};
1261
139k
        ::Unserialize(ss, m_object);
1262
139k
    }
void ParamsWrapper<TransactionSerParams, CBlock>::Unserialize<BufferedFile>(BufferedFile&)
Line
Count
Source
1259
1.91k
    {
1260
1.91k
        ParamsStream ss{s, m_params};
1261
1.91k
        ::Unserialize(ss, m_object);
1262
1.91k
    }
1263
};
1264
1265
/**
1266
 * Helper macro for SerParams structs
1267
 *
1268
 * Allows you define SerParams instances and then apply them directly
1269
 * to an object via function call syntax, eg:
1270
 *
1271
 *   constexpr SerParams FOO{....};
1272
 *   ss << FOO(obj);
1273
 */
1274
#define SER_PARAMS_OPFUNC                                                                \
1275
    /**                                                                                  \
1276
     * Return a wrapper around t that (de)serializes it with specified parameter params. \
1277
     *                                                                                   \
1278
     * See SER_PARAMS for more information on serialization parameters.                  \
1279
     */                                                                                  \
1280
    template <typename T>                                                                \
1281
    auto operator()(T&& t) const                                                         \
1282
6.37M
    {                                                                                    \
1283
6.37M
        return ParamsWrapper{*this, t};                                                  \
1284
6.37M
    }
auto TransactionSerParams::operator()<CTransaction const&>(CTransaction const&) const
Line
Count
Source
1282
4.35M
    {                                                                                    \
1283
4.35M
        return ParamsWrapper{*this, t};                                                  \
1284
4.35M
    }
auto TransactionSerParams::operator()<CBlock const&>(CBlock const&) const
Line
Count
Source
1282
821k
    {                                                                                    \
1283
821k
        return ParamsWrapper{*this, t};                                                  \
1284
821k
    }
auto TransactionSerParams::operator()<CTxIn const&>(CTxIn const&) const
Line
Count
Source
1282
4.99k
    {                                                                                    \
1283
4.99k
        return ParamsWrapper{*this, t};                                                  \
1284
4.99k
    }
auto CNetAddr::SerParams::operator()<CService const&>(CService const&) const
Line
Count
Source
1282
69.3k
    {                                                                                    \
1283
69.3k
        return ParamsWrapper{*this, t};                                                  \
1284
69.3k
    }
auto CAddress::SerParams::operator()<AddrInfo&>(AddrInfo&) const
Line
Count
Source
1282
2
    {                                                                                    \
1283
2
        return ParamsWrapper{*this, t};                                                  \
1284
2
    }
auto TransactionSerParams::operator()<Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>>(Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const>&>&&) const
Line
Count
Source
1282
21.6k
    {                                                                                    \
1283
21.6k
        return ParamsWrapper{*this, t};                                                  \
1284
21.6k
    }
auto TransactionSerParams::operator()<Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>>(Wrapper<DefaultFormatter, std::shared_ptr<CTransaction const> const&>&&) const
Line
Count
Source
1282
54.5k
    {                                                                                    \
1283
54.5k
        return ParamsWrapper{*this, t};                                                  \
1284
54.5k
    }
auto TransactionSerParams::operator()<CBlock&>(CBlock&) const
Line
Count
Source
1282
176k
    {                                                                                    \
1283
176k
        return ParamsWrapper{*this, t};                                                  \
1284
176k
    }
auto TransactionSerParams::operator()<CMutableTransaction&>(CMutableTransaction&) const
Line
Count
Source
1282
96.8k
    {                                                                                    \
1283
96.8k
        return ParamsWrapper{*this, t};                                                  \
1284
96.8k
    }
auto CAddress::SerParams::operator()<CNetAddr&>(CNetAddr&) const
Line
Count
Source
1282
30
    {                                                                                    \
1283
30
        return ParamsWrapper{*this, t};                                                  \
1284
30
    }
auto CAddress::SerParams::operator()<CService const&>(CService const&) const
Line
Count
Source
1282
1
    {                                                                                    \
1283
1
        return ParamsWrapper{*this, t};                                                  \
1284
1
    }
auto CNetAddr::SerParams::operator()<CService&>(CService&) const
Line
Count
Source
1282
30.9k
    {                                                                                    \
1283
30.9k
        return ParamsWrapper{*this, t};                                                  \
1284
30.9k
    }
auto CAddress::SerParams::operator()<std::vector<CAddress, std::allocator<CAddress>>&>(std::vector<CAddress, std::allocator<CAddress>>&) const
Line
Count
Source
1282
234
    {                                                                                    \
1283
234
        return ParamsWrapper{*this, t};                                                  \
1284
234
    }
auto CAddress::SerParams::operator()<std::vector<CAddress, std::allocator<CAddress>> const&>(std::vector<CAddress, std::allocator<CAddress>> const&) const
Line
Count
Source
1282
41
    {                                                                                    \
1283
41
        return ParamsWrapper{*this, t};                                                  \
1284
41
    }
auto TransactionSerParams::operator()<std::shared_ptr<CTransaction const> const&>(std::shared_ptr<CTransaction const> const&) const
Line
Count
Source
1282
18.8k
    {                                                                                    \
1283
18.8k
        return ParamsWrapper{*this, t};                                                  \
1284
18.8k
    }
auto TransactionSerParams::operator()<std::shared_ptr<CTransaction const>&>(std::shared_ptr<CTransaction const>&) const
Line
Count
Source
1282
37.2k
    {                                                                                    \
1283
37.2k
        return ParamsWrapper{*this, t};                                                  \
1284
37.2k
    }
auto TransactionSerParams::operator()<CMutableTransaction>(CMutableTransaction&&) const
Line
Count
Source
1282
59
    {                                                                                    \
1283
59
        return ParamsWrapper{*this, t};                                                  \
1284
59
    }
auto serialize_tests::OtherParam::operator()<serialize_tests::OtherParamChecker const&>(serialize_tests::OtherParamChecker const&) const
Line
Count
Source
1282
2
    {                                                                                    \
1283
2
        return ParamsWrapper{*this, t};                                                  \
1284
2
    }
auto serialize_tests::BaseFormat::operator()<serialize_tests::Base&>(serialize_tests::Base&) const
Line
Count
Source
1282
4
    {                                                                                    \
1283
4
        return ParamsWrapper{*this, t};                                                  \
1284
4
    }
auto serialize_tests::BaseFormat::operator()<std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>&>(std::vector<serialize_tests::Base, std::allocator<serialize_tests::Base>>&) const
Line
Count
Source
1282
4
    {                                                                                    \
1283
4
        return ParamsWrapper{*this, t};                                                  \
1284
4
    }
auto serialize_tests::DerivedAndBaseFormat::operator()<serialize_tests::Derived&>(serialize_tests::Derived&) const
Line
Count
Source
1282
2
    {                                                                                    \
1283
2
        return ParamsWrapper{*this, t};                                                  \
1284
2
    }
auto serialize_tests::BaseFormat::operator()<serialize_tests::Base const&>(serialize_tests::Base const&) const
Line
Count
Source
1282
2
    {                                                                                    \
1283
2
        return ParamsWrapper{*this, t};                                                  \
1284
2
    }
auto TransactionSerParams::operator()<CTransaction>(CTransaction&&) const
Line
Count
Source
1282
1
    {                                                                                    \
1283
1
        return ParamsWrapper{*this, t};                                                  \
1284
1
    }
auto TransactionSerParams::operator()<std::shared_ptr<CTransaction const>>(std::shared_ptr<CTransaction const>&&) const
Line
Count
Source
1282
24.7k
    {                                                                                    \
1283
24.7k
        return ParamsWrapper{*this, t};                                                  \
1284
24.7k
    }
auto CNetAddr::SerParams::operator()<CService>(CService&&) const
Line
Count
Source
1282
1.74k
    {                                                                                    \
1283
1.74k
        return ParamsWrapper{*this, t};                                                  \
1284
1.74k
    }
auto TransactionSerParams::operator()<Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>>(Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>> const&>&&) const
Line
Count
Source
1282
590
    {                                                                                    \
1283
590
        return ParamsWrapper{*this, t};                                                  \
1284
590
    }
auto TransactionSerParams::operator()<std::vector<CBlock, std::allocator<CBlock>>&>(std::vector<CBlock, std::allocator<CBlock>>&) const
Line
Count
Source
1282
5.27k
    {                                                                                    \
1283
5.27k
        return ParamsWrapper{*this, t};                                                  \
1284
5.27k
    }
auto TransactionSerParams::operator()<Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>>(Wrapper<VectorFormatter<DefaultFormatter>, std::vector<std::shared_ptr<CTransaction const>, std::allocator<std::shared_ptr<CTransaction const>>>&>&&) const
Line
Count
Source
1282
572
    {                                                                                    \
1283
572
        return ParamsWrapper{*this, t};                                                  \
1284
572
    }
auto TransactionSerParams::operator()<CMutableTransaction const&>(CMutableTransaction const&) const
Line
Count
Source
1282
661k
    {                                                                                    \
1283
661k
        return ParamsWrapper{*this, t};                                                  \
1284
661k
    }
1285
1286
#endif // BITCOIN_SERIALIZE_H