Coverage Report

Created: 2026-04-29 19:21

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/tmp/bitcoin/src/univalue/include/univalue.h
Line
Count
Source
1
// Copyright 2014 BitPay Inc.
2
// Copyright 2015 Bitcoin Core Developers
3
// Distributed under the MIT software license, see the accompanying
4
// file COPYING or https://opensource.org/licenses/mit-license.php.
5
6
#ifndef BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_H
7
#define BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_H
8
9
#include <charconv>
10
#include <cstddef>
11
#include <cstdint>
12
#include <map>
13
#include <stdexcept>
14
#include <string>
15
#include <string_view>
16
#include <system_error>
17
#include <type_traits>
18
#include <utility>
19
#include <vector>
20
21
// NOLINTNEXTLINE(misc-no-recursion)
22
class UniValue {
23
public:
24
    enum VType { VNULL, VOBJ, VARR, VSTR, VNUM, VBOOL, };
25
26
    class type_error : public std::runtime_error
27
    {
28
        using std::runtime_error::runtime_error;
29
    };
30
31
5.39M
    UniValue() { typ = VNULL; }
32
3.83M
    UniValue(UniValue::VType type, std::string str = {}) : typ{type}, val{std::move(str)} {}
33
    template <typename Ref, typename T = std::remove_cv_t<std::remove_reference_t<Ref>>,
34
              std::enable_if_t<std::is_floating_point_v<T> ||                      // setFloat
35
                                   std::is_same_v<bool, T> ||                      // setBool
36
                                   std::is_signed_v<T> || std::is_unsigned_v<T> || // setInt
37
                                   std::is_constructible_v<std::string, T>,        // setStr
38
                               bool> = true>
39
    UniValue(Ref&& val)
40
10.4M
    {
41
10.4M
        if constexpr (std::is_floating_point_v<T>) {
42
63.5k
            setFloat(val);
43
6.10M
        } else if constexpr (std::is_same_v<bool, T>) {
44
6.10M
            setBool(val);
45
6.10M
        } else if constexpr (std::is_signed_v<T>) {
46
679k
            setInt(int64_t{val});
47
904k
        } else if constexpr (std::is_unsigned_v<T>) {
48
904k
            setInt(uint64_t{val});
49
2.68M
        } else {
50
2.68M
            setStr(std::string{std::forward<Ref>(val)});
51
2.68M
        }
52
10.4M
    }
UniValue::UniValue<bool, bool, true>(bool&&)
Line
Count
Source
40
5.92M
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
5.92M
        } else if constexpr (std::is_same_v<bool, T>) {
44
5.92M
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
5.92M
    }
UniValue::UniValue<char const (&) [1], char [1], true>(char const (&) [1])
Line
Count
Source
40
15.6k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
15.6k
        } else {
50
15.6k
            setStr(std::string{std::forward<Ref>(val)});
51
15.6k
        }
52
15.6k
    }
UniValue::UniValue<char const (&) [2], char [2], true>(char const (&) [2])
Line
Count
Source
40
16
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
16
        } else {
50
16
            setStr(std::string{std::forward<Ref>(val)});
51
16
        }
52
16
    }
UniValue::UniValue<char const (&) [4], char [4], true>(char const (&) [4])
Line
Count
Source
40
187k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
187k
        } else {
50
187k
            setStr(std::string{std::forward<Ref>(val)});
51
187k
        }
52
187k
    }
UniValue::UniValue<char const (&) [10], char [10], true>(char const (&) [10])
Line
Count
Source
40
2.19k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
2.19k
        } else {
50
2.19k
            setStr(std::string{std::forward<Ref>(val)});
51
2.19k
        }
52
2.19k
    }
UniValue::UniValue<char const (&) [6], char [6], true>(char const (&) [6])
Line
Count
Source
40
14.1k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
14.1k
        } else {
50
14.1k
            setStr(std::string{std::forward<Ref>(val)});
51
14.1k
        }
52
14.1k
    }
UniValue::UniValue<char const (&) [18], char [18], true>(char const (&) [18])
Line
Count
Source
40
2.38k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
2.38k
        } else {
50
2.38k
            setStr(std::string{std::forward<Ref>(val)});
51
2.38k
        }
52
2.38k
    }
UniValue::UniValue<char const (&) [3], char [3], true>(char const (&) [3])
Line
Count
Source
40
894
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
894
        } else {
50
894
            setStr(std::string{std::forward<Ref>(val)});
51
894
        }
52
894
    }
UniValue::UniValue<char const (&) [5], char [5], true>(char const (&) [5])
Line
Count
Source
40
7.02k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
7.02k
        } else {
50
7.02k
            setStr(std::string{std::forward<Ref>(val)});
51
7.02k
        }
52
7.02k
    }
UniValue::UniValue<int, int, true>(int&&)
Line
Count
Source
40
258k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
258k
        } else if constexpr (std::is_signed_v<T>) {
46
258k
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
258k
    }
UniValue::UniValue<double, double, true>(double&&)
Line
Count
Source
40
63.2k
    {
41
63.2k
        if constexpr (std::is_floating_point_v<T>) {
42
63.2k
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
63.2k
    }
UniValue::UniValue<char const (&) [7], char [7], true>(char const (&) [7])
Line
Count
Source
40
3.80k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
3.80k
        } else {
50
3.80k
            setStr(std::string{std::forward<Ref>(val)});
51
3.80k
        }
52
3.80k
    }
UniValue::UniValue<unsigned long const&, unsigned long, true>(unsigned long const&)
Line
Count
Source
40
325k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
325k
        } else if constexpr (std::is_unsigned_v<T>) {
48
325k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
325k
    }
UniValue::UniValue<char const* const&, char const*, true>(char const* const&)
Line
Count
Source
40
1
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
1
        } else {
50
1
            setStr(std::string{std::forward<Ref>(val)});
51
1
        }
52
1
    }
UniValue::UniValue<bool const&, bool, true>(bool const&)
Line
Count
Source
40
116k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
116k
        } else if constexpr (std::is_same_v<bool, T>) {
44
116k
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
116k
    }
UniValue::UniValue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, true>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&)
Line
Count
Source
40
1.80M
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
1.80M
        } else {
50
1.80M
            setStr(std::string{std::forward<Ref>(val)});
51
1.80M
        }
52
1.80M
    }
UniValue::UniValue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, true>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Line
Count
Source
40
184k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
184k
        } else {
50
184k
            setStr(std::string{std::forward<Ref>(val)});
51
184k
        }
52
184k
    }
UniValue::UniValue<std::basic_string_view<char, std::char_traits<char>>&, std::basic_string_view<char, std::char_traits<char>>, true>(std::basic_string_view<char, std::char_traits<char>>&)
Line
Count
Source
40
158
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
158
        } else {
50
158
            setStr(std::string{std::forward<Ref>(val)});
51
158
        }
52
158
    }
UniValue::UniValue<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>>, true>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&&)
Line
Count
Source
40
259k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
259k
        } else {
50
259k
            setStr(std::string{std::forward<Ref>(val)});
51
259k
        }
52
259k
    }
UniValue::UniValue<int&, int, true>(int&)
Line
Count
Source
40
94.9k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
94.9k
        } else if constexpr (std::is_signed_v<T>) {
46
94.9k
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
94.9k
    }
UniValue::UniValue<unsigned int const&, unsigned int, true>(unsigned int const&)
Line
Count
Source
40
383k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
383k
        } else if constexpr (std::is_unsigned_v<T>) {
48
383k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
383k
    }
UniValue::UniValue<long const&, long, true>(long const&)
Line
Count
Source
40
25.8k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
25.8k
        } else if constexpr (std::is_signed_v<T>) {
46
25.8k
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
25.8k
    }
UniValue::UniValue<long&, long, true>(long&)
Line
Count
Source
40
25.3k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
25.3k
        } else if constexpr (std::is_signed_v<T>) {
46
25.3k
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
25.3k
    }
UniValue::UniValue<bool&, bool, true>(bool&)
Line
Count
Source
40
64.5k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
64.5k
        } else if constexpr (std::is_same_v<bool, T>) {
44
64.5k
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
64.5k
    }
UniValue::UniValue<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>>, true>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Line
Count
Source
40
170k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
170k
        } else {
50
170k
            setStr(std::string{std::forward<Ref>(val)});
51
170k
        }
52
170k
    }
UniValue::UniValue<char const (&) [8], char [8], true>(char const (&) [8])
Line
Count
Source
40
5.40k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
5.40k
        } else {
50
5.40k
            setStr(std::string{std::forward<Ref>(val)});
51
5.40k
        }
52
5.40k
    }
UniValue::UniValue<int const&, int, true>(int const&)
Line
Count
Source
40
108k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
108k
        } else if constexpr (std::is_signed_v<T>) {
46
108k
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
108k
    }
UniValue::UniValue<long, long, true>(long&&)
Line
Count
Source
40
166k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
166k
        } else if constexpr (std::is_signed_v<T>) {
46
166k
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
166k
    }
UniValue::UniValue<unsigned long, unsigned long, true>(unsigned long&&)
Line
Count
Source
40
56.4k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
56.4k
        } else if constexpr (std::is_unsigned_v<T>) {
48
56.4k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
56.4k
    }
UniValue::UniValue<char const (&) [26], char [26], true>(char const (&) [26])
Line
Count
Source
40
2.40k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
2.40k
        } else {
50
2.40k
            setStr(std::string{std::forward<Ref>(val)});
51
2.40k
        }
52
2.40k
    }
UniValue::UniValue<unsigned int&, unsigned int, true>(unsigned int&)
Line
Count
Source
40
17.4k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
17.4k
        } else if constexpr (std::is_unsigned_v<T>) {
48
17.4k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
17.4k
    }
UniValue::UniValue<unsigned long&, unsigned long, true>(unsigned long&)
Line
Count
Source
40
75.2k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
75.2k
        } else if constexpr (std::is_unsigned_v<T>) {
48
75.2k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
75.2k
    }
UniValue::UniValue<char const (&) [11], char [11], true>(char const (&) [11])
Line
Count
Source
40
4.18k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
4.18k
        } else {
50
4.18k
            setStr(std::string{std::forward<Ref>(val)});
51
4.18k
        }
52
4.18k
    }
UniValue::UniValue<char const (&) [38], char [38], true>(char const (&) [38])
Line
Count
Source
40
8
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
8
        } else {
50
8
            setStr(std::string{std::forward<Ref>(val)});
51
8
        }
52
8
    }
UniValue::UniValue<double&, double, true>(double&)
Line
Count
Source
40
320
    {
41
320
        if constexpr (std::is_floating_point_v<T>) {
42
320
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
320
    }
UniValue::UniValue<char const (&) [60], char [60], true>(char const (&) [60])
Line
Count
Source
40
9
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
9
        } else {
50
9
            setStr(std::string{std::forward<Ref>(val)});
51
9
        }
52
9
    }
UniValue::UniValue<char const (&) [17], char [17], true>(char const (&) [17])
Line
Count
Source
40
2.08k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
2.08k
        } else {
50
2.08k
            setStr(std::string{std::forward<Ref>(val)});
51
2.08k
        }
52
2.08k
    }
UniValue::UniValue<char const (&) [15], char [15], true>(char const (&) [15])
Line
Count
Source
40
116
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
116
        } else {
50
116
            setStr(std::string{std::forward<Ref>(val)});
51
116
        }
52
116
    }
UniValue::UniValue<char const (&) [87], char [87], true>(char const (&) [87])
Line
Count
Source
40
2.40k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
2.40k
        } else {
50
2.40k
            setStr(std::string{std::forward<Ref>(val)});
51
2.40k
        }
52
2.40k
    }
UniValue::UniValue<char const (&) [22], char [22], true>(char const (&) [22])
Line
Count
Source
40
6
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
6
        } else {
50
6
            setStr(std::string{std::forward<Ref>(val)});
51
6
        }
52
6
    }
UniValue::UniValue<unsigned int, unsigned int, true>(unsigned int&&)
Line
Count
Source
40
18.1k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
18.1k
        } else if constexpr (std::is_unsigned_v<T>) {
48
18.1k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
18.1k
    }
UniValue::UniValue<char const (&) [23], char [23], true>(char const (&) [23])
Line
Count
Source
40
2
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
2
        } else {
50
2
            setStr(std::string{std::forward<Ref>(val)});
51
2
        }
52
2
    }
UniValue::UniValue<char const (&) [9], char [9], true>(char const (&) [9])
Line
Count
Source
40
2.79k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
2.79k
        } else {
50
2.79k
            setStr(std::string{std::forward<Ref>(val)});
51
2.79k
        }
52
2.79k
    }
UniValue::UniValue<char const (&) [13], char [13], true>(char const (&) [13])
Line
Count
Source
40
2.20k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
2.20k
        } else {
50
2.20k
            setStr(std::string{std::forward<Ref>(val)});
51
2.20k
        }
52
2.20k
    }
Unexecuted instantiation: UniValue::UniValue<char const*, char const*, true>(char const*&&)
UniValue::UniValue<unsigned short const&, unsigned short, true>(unsigned short const&)
Line
Count
Source
40
4
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
4
        } else if constexpr (std::is_unsigned_v<T>) {
48
4
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
4
    }
UniValue::UniValue<char const (&) [21], char [21], true>(char const (&) [21])
Line
Count
Source
40
3.81k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
3.81k
        } else {
50
3.81k
            setStr(std::string{std::forward<Ref>(val)});
51
3.81k
        }
52
3.81k
    }
UniValue::UniValue<unsigned short, unsigned short, true>(unsigned short&&)
Line
Count
Source
40
27.6k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
27.6k
        } else if constexpr (std::is_unsigned_v<T>) {
48
27.6k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
27.6k
    }
UniValue::UniValue<char const (&) [91], char [91], true>(char const (&) [91])
Line
Count
Source
40
12
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
12
        } else {
50
12
            setStr(std::string{std::forward<Ref>(val)});
51
12
        }
52
12
    }
UniValue::UniValue<unsigned char const&, unsigned char, true>(unsigned char const&)
Line
Count
Source
40
664
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
664
        } else if constexpr (std::is_unsigned_v<T>) {
48
664
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
664
    }
UniValue::UniValue<char const (&) [35], char [35], true>(char const (&) [35])
Line
Count
Source
40
7.26k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
7.26k
        } else {
50
7.26k
            setStr(std::string{std::forward<Ref>(val)});
51
7.26k
        }
52
7.26k
    }
UniValue::UniValue<char const (&) [12], char [12], true>(char const (&) [12])
Line
Count
Source
40
2.81k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
2.81k
        } else {
50
2.81k
            setStr(std::string{std::forward<Ref>(val)});
51
2.81k
        }
52
2.81k
    }
UniValue::UniValue<char const (&) [103], char [103], true>(char const (&) [103])
Line
Count
Source
40
82
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
82
        } else {
50
82
            setStr(std::string{std::forward<Ref>(val)});
51
82
        }
52
82
    }
UniValue::UniValue<unsigned char&, unsigned char, true>(unsigned char&)
Line
Count
Source
40
16
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
16
        } else if constexpr (std::is_unsigned_v<T>) {
48
16
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
16
    }
UniValue::UniValue<char const (&) [30], char [30], true>(char const (&) [30])
Line
Count
Source
40
1.69k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
1.69k
        } else {
50
1.69k
            setStr(std::string{std::forward<Ref>(val)});
51
1.69k
        }
52
1.69k
    }
UniValue::UniValue<char const (&) [45], char [45], true>(char const (&) [45])
Line
Count
Source
40
345
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
345
        } else {
50
345
            setStr(std::string{std::forward<Ref>(val)});
51
345
        }
52
345
    }
UniValue::UniValue<char const (&) [86], char [86], true>(char const (&) [86])
Line
Count
Source
40
225
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
225
        } else {
50
225
            setStr(std::string{std::forward<Ref>(val)});
51
225
        }
52
225
    }
UniValue::UniValue<char const (&) [54], char [54], true>(char const (&) [54])
Line
Count
Source
40
1
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
1
        } else {
50
1
            setStr(std::string{std::forward<Ref>(val)});
51
1
        }
52
1
    }
UniValue::UniValue<char const (&) [137], char [137], true>(char const (&) [137])
Line
Count
Source
40
16
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
16
        } else {
50
16
            setStr(std::string{std::forward<Ref>(val)});
51
16
        }
52
16
    }
UniValue::UniValue<char const (&) [33], char [33], true>(char const (&) [33])
Line
Count
Source
40
21
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
        } else if constexpr (std::is_same_v<bool, T>) {
44
            setBool(val);
45
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
21
        } else {
50
21
            setStr(std::string{std::forward<Ref>(val)});
51
21
        }
52
21
    }
Unexecuted instantiation: UniValue::UniValue<char const (&) [47], char [47], true>(char const (&) [47])
53
54
    void clear();
55
56
    void setNull();
57
    void setBool(bool val);
58
    void setNumStr(std::string str);
59
    void setInt(uint64_t val);
60
    void setInt(int64_t val);
61
    void setInt(int val_) { return setInt(int64_t{val_}); }
62
    void setFloat(double val);
63
    void setStr(std::string str);
64
    void setArray();
65
    void setObject();
66
67
17.4M
    enum VType getType() const { return typ; }
68
1.45M
    const std::string& getValStr() const { return val; }
69
1.25M
    bool empty() const { return (values.size() == 0); }
70
71
1.98M
    size_t size() const { return values.size(); }
72
73
    void reserve(size_t new_cap);
74
75
    void getObjMap(std::map<std::string,UniValue>& kv) const;
76
    bool checkObject(const std::map<std::string,UniValue::VType>& memberTypes) const;
77
    const UniValue& operator[](const std::string& key) const;
78
    const UniValue& operator[](size_t index) const;
79
216k
    bool exists(const std::string& key) const { size_t i; return findKey(key, i); }
80
81
2.41M
    bool isNull() const { return (typ == VNULL); }
82
5.51M
    bool isTrue() const { return (typ == VBOOL) && (val == "1"); }
83
2.19M
    bool isFalse() const { return (typ == VBOOL) && (val != "1"); }
84
220k
    bool isBool() const { return (typ == VBOOL); }
85
395k
    bool isStr() const { return (typ == VSTR); }
86
121k
    bool isNum() const { return (typ == VNUM); }
87
295k
    bool isArray() const { return (typ == VARR); }
88
646k
    bool isObject() const { return (typ == VOBJ); }
89
90
    void push_back(UniValue val);
91
    void push_backV(const std::vector<UniValue>& vec);
92
    template <class It>
93
    void push_backV(It first, It last);
94
95
    void pushKVEnd(std::string key, UniValue val);
96
    void pushKV(std::string key, UniValue val);
97
    void pushKVs(UniValue obj);
98
99
    std::string write(unsigned int prettyIndent = 0,
100
                      unsigned int indentLevel = 0) const;
101
102
    bool read(std::string_view raw);
103
104
private:
105
    UniValue::VType typ;
106
    std::string val;                       // numbers are stored as C++ strings
107
    std::vector<std::string> keys;
108
    std::vector<UniValue> values;
109
110
    void checkType(const VType& expected) const;
111
    bool findKey(const std::string& key, size_t& retIdx) const;
112
    void writeArray(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const;
113
    void writeObject(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const;
114
115
public:
116
    // Strict type-specific getters, these throw std::runtime_error if the
117
    // value is of unexpected type
118
    const std::vector<std::string>& getKeys() const;
119
    const std::vector<UniValue>& getValues() const;
120
    template <typename Int>
121
    Int getInt() const;
122
    bool get_bool() const;
123
    const std::string& get_str() const;
124
    double get_real() const;
125
    const UniValue& get_obj() const;
126
    const UniValue& get_array() const;
127
128
18.4k
    enum VType type() const { return getType(); }
129
    const UniValue& find_value(std::string_view key) const;
130
};
131
132
template <class It>
133
void UniValue::push_backV(It first, It last)
134
225
{
135
225
    checkType(VARR);
136
225
    values.insert(values.end(), first, last);
137
225
}
void UniValue::push_backV<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>)
Line
Count
Source
134
91
{
135
91
    checkType(VARR);
136
91
    values.insert(values.end(), first, last);
137
91
}
void UniValue::push_backV<std::move_iterator<std::reverse_iterator<__gnu_cxx::__normal_iterator<UniValue*, std::vector<UniValue, std::allocator<UniValue>>>>>>(std::move_iterator<std::reverse_iterator<__gnu_cxx::__normal_iterator<UniValue*, std::vector<UniValue, std::allocator<UniValue>>>>>, std::move_iterator<std::reverse_iterator<__gnu_cxx::__normal_iterator<UniValue*, std::vector<UniValue, std::allocator<UniValue>>>>>)
Line
Count
Source
134
134
{
135
134
    checkType(VARR);
136
134
    values.insert(values.end(), first, last);
137
134
}
138
139
template <typename Int>
140
Int UniValue::getInt() const
141
64.1k
{
142
64.1k
    static_assert(std::is_integral_v<Int>);
143
64.1k
    checkType(VNUM);
144
64.1k
    Int result;
145
64.1k
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
146
64.1k
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
147
9
        throw std::runtime_error("JSON integer out of range");
148
9
    }
149
64.1k
    return result;
150
64.1k
}
int UniValue::getInt<int>() const
Line
Count
Source
141
21.8k
{
142
21.8k
    static_assert(std::is_integral_v<Int>);
143
21.8k
    checkType(VNUM);
144
21.8k
    Int result;
145
21.8k
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
146
21.8k
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
147
1
        throw std::runtime_error("JSON integer out of range");
148
1
    }
149
21.8k
    return result;
150
21.8k
}
long UniValue::getInt<long>() const
Line
Count
Source
141
8.13k
{
142
8.13k
    static_assert(std::is_integral_v<Int>);
143
8.13k
    checkType(VNUM);
144
8.13k
    Int result;
145
8.13k
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
146
8.13k
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
147
2
        throw std::runtime_error("JSON integer out of range");
148
2
    }
149
8.13k
    return result;
150
8.13k
}
unsigned long UniValue::getInt<unsigned long>() const
Line
Count
Source
141
830
{
142
830
    static_assert(std::is_integral_v<Int>);
143
830
    checkType(VNUM);
144
830
    Int result;
145
830
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
146
830
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
147
0
        throw std::runtime_error("JSON integer out of range");
148
0
    }
149
830
    return result;
150
830
}
unsigned int UniValue::getInt<unsigned int>() const
Line
Count
Source
141
991
{
142
991
    static_assert(std::is_integral_v<Int>);
143
991
    checkType(VNUM);
144
991
    Int result;
145
991
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
146
991
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
147
1
        throw std::runtime_error("JSON integer out of range");
148
1
    }
149
990
    return result;
150
991
}
unsigned short UniValue::getInt<unsigned short>() const
Line
Count
Source
141
32.3k
{
142
32.3k
    static_assert(std::is_integral_v<Int>);
143
32.3k
    checkType(VNUM);
144
32.3k
    Int result;
145
32.3k
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
146
32.3k
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
147
4
        throw std::runtime_error("JSON integer out of range");
148
4
    }
149
32.3k
    return result;
150
32.3k
}
signed char UniValue::getInt<signed char>() const
Line
Count
Source
141
1
{
142
1
    static_assert(std::is_integral_v<Int>);
143
1
    checkType(VNUM);
144
1
    Int result;
145
1
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
146
1
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
147
0
        throw std::runtime_error("JSON integer out of range");
148
0
    }
149
1
    return result;
150
1
}
unsigned char UniValue::getInt<unsigned char>() const
Line
Count
Source
141
1
{
142
1
    static_assert(std::is_integral_v<Int>);
143
1
    checkType(VNUM);
144
1
    Int result;
145
1
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
146
1
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
147
1
        throw std::runtime_error("JSON integer out of range");
148
1
    }
149
0
    return result;
150
1
}
Unexecuted instantiation: short UniValue::getInt<short>() const
151
152
enum jtokentype {
153
    JTOK_ERR        = -1,
154
    JTOK_NONE       = 0,                           // eof
155
    JTOK_OBJ_OPEN,
156
    JTOK_OBJ_CLOSE,
157
    JTOK_ARR_OPEN,
158
    JTOK_ARR_CLOSE,
159
    JTOK_COLON,
160
    JTOK_COMMA,
161
    JTOK_KW_NULL,
162
    JTOK_KW_TRUE,
163
    JTOK_KW_FALSE,
164
    JTOK_NUMBER,
165
    JTOK_STRING,
166
};
167
168
extern enum jtokentype getJsonToken(std::string& tokenVal,
169
                                    unsigned int& consumed, const char *raw, const char *end);
170
extern const char *uvTypeName(UniValue::VType t);
171
172
static inline bool jsonTokenIsValue(enum jtokentype jtt)
173
4.48M
{
174
4.48M
    switch (jtt) {
175
659
    case JTOK_KW_NULL:
176
15.9k
    case JTOK_KW_TRUE:
177
18.1k
    case JTOK_KW_FALSE:
178
298k
    case JTOK_NUMBER:
179
1.87M
    case JTOK_STRING:
180
1.87M
        return true;
181
182
2.60M
    default:
183
2.60M
        return false;
184
4.48M
    }
185
186
    // not reached
187
4.48M
}
Unexecuted instantiation: argsman_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: base58_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: blockfilter_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: getarg_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: key_io_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: node_init_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: rpc_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: script_assets_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: script_standard_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: script_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: settings_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: sighash_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: system_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: transaction_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: util_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: validation_chainstate_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: validation_chainstatemanager_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: init_test_fixture.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: wallet_rpc_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: wallet_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: ipc_tests.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: json.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: setup_common.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: client.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: addrdb.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: init.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: interfaces.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: warnings.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: rest.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: blockchain.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: external_signer.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: fees.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: mempool.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: mining.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: net.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: node.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: output_script.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: rawtransaction.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: server.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: server_util.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: signmessage.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: txoutproof.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: httprpc.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: load.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: util.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: wallet.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: external_signer_scriptpubkeyman.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: addresses.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: backup.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: coins.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: encrypt.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: spend.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: transactions.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: ipc_test.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: ipc_test.capnp.proxy-client.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: ipc_test.capnp.proxy-types.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: ipc_test.capnp.proxy-server.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: init.capnp.proxy-client.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: init.capnp.proxy-types.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: mining.capnp.proxy-types.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: rpc.capnp.proxy-types.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: init.capnp.proxy-server.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: mining.capnp.proxy-client.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: mining.capnp.proxy-server.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: rpc.capnp.proxy-client.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: rpc.capnp.proxy-server.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: args.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: config.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: run_command.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: settings.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: core_io.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: net_types.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: rawtransaction_util.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: request.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: univalue.cpp:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: univalue_get.cpp:jsonTokenIsValue(jtokentype)
univalue_read.cpp:jsonTokenIsValue(jtokentype)
Line
Count
Source
173
4.48M
{
174
4.48M
    switch (jtt) {
175
659
    case JTOK_KW_NULL:
176
15.9k
    case JTOK_KW_TRUE:
177
18.1k
    case JTOK_KW_FALSE:
178
298k
    case JTOK_NUMBER:
179
1.87M
    case JTOK_STRING:
180
1.87M
        return true;
181
182
2.60M
    default:
183
2.60M
        return false;
184
4.48M
    }
185
186
    // not reached
187
4.48M
}
Unexecuted instantiation: univalue_write.cpp:jsonTokenIsValue(jtokentype)
188
189
static inline bool json_isspace(int ch)
190
7.93M
{
191
7.93M
    switch (ch) {
192
1.78M
    case 0x20:
193
1.78M
    case 0x09:
194
1.80M
    case 0x0a:
195
1.80M
    case 0x0d:
196
1.80M
        return true;
197
198
6.13M
    default:
199
6.13M
        return false;
200
7.93M
    }
201
202
    // not reached
203
7.93M
}
Unexecuted instantiation: argsman_tests.cpp:json_isspace(int)
Unexecuted instantiation: base58_tests.cpp:json_isspace(int)
Unexecuted instantiation: blockfilter_tests.cpp:json_isspace(int)
Unexecuted instantiation: getarg_tests.cpp:json_isspace(int)
Unexecuted instantiation: key_io_tests.cpp:json_isspace(int)
Unexecuted instantiation: node_init_tests.cpp:json_isspace(int)
Unexecuted instantiation: rpc_tests.cpp:json_isspace(int)
Unexecuted instantiation: script_assets_tests.cpp:json_isspace(int)
Unexecuted instantiation: script_standard_tests.cpp:json_isspace(int)
Unexecuted instantiation: script_tests.cpp:json_isspace(int)
Unexecuted instantiation: settings_tests.cpp:json_isspace(int)
Unexecuted instantiation: sighash_tests.cpp:json_isspace(int)
Unexecuted instantiation: system_tests.cpp:json_isspace(int)
Unexecuted instantiation: transaction_tests.cpp:json_isspace(int)
Unexecuted instantiation: util_tests.cpp:json_isspace(int)
Unexecuted instantiation: validation_chainstate_tests.cpp:json_isspace(int)
Unexecuted instantiation: validation_chainstatemanager_tests.cpp:json_isspace(int)
Unexecuted instantiation: init_test_fixture.cpp:json_isspace(int)
Unexecuted instantiation: wallet_rpc_tests.cpp:json_isspace(int)
Unexecuted instantiation: wallet_tests.cpp:json_isspace(int)
Unexecuted instantiation: ipc_tests.cpp:json_isspace(int)
Unexecuted instantiation: json.cpp:json_isspace(int)
Unexecuted instantiation: setup_common.cpp:json_isspace(int)
Unexecuted instantiation: client.cpp:json_isspace(int)
Unexecuted instantiation: addrdb.cpp:json_isspace(int)
Unexecuted instantiation: init.cpp:json_isspace(int)
Unexecuted instantiation: interfaces.cpp:json_isspace(int)
Unexecuted instantiation: warnings.cpp:json_isspace(int)
Unexecuted instantiation: rest.cpp:json_isspace(int)
Unexecuted instantiation: blockchain.cpp:json_isspace(int)
Unexecuted instantiation: external_signer.cpp:json_isspace(int)
Unexecuted instantiation: fees.cpp:json_isspace(int)
Unexecuted instantiation: mempool.cpp:json_isspace(int)
Unexecuted instantiation: mining.cpp:json_isspace(int)
Unexecuted instantiation: net.cpp:json_isspace(int)
Unexecuted instantiation: node.cpp:json_isspace(int)
Unexecuted instantiation: output_script.cpp:json_isspace(int)
Unexecuted instantiation: rawtransaction.cpp:json_isspace(int)
Unexecuted instantiation: server.cpp:json_isspace(int)
Unexecuted instantiation: server_util.cpp:json_isspace(int)
Unexecuted instantiation: signmessage.cpp:json_isspace(int)
Unexecuted instantiation: txoutproof.cpp:json_isspace(int)
Unexecuted instantiation: httprpc.cpp:json_isspace(int)
Unexecuted instantiation: load.cpp:json_isspace(int)
Unexecuted instantiation: util.cpp:json_isspace(int)
Unexecuted instantiation: wallet.cpp:json_isspace(int)
Unexecuted instantiation: external_signer_scriptpubkeyman.cpp:json_isspace(int)
Unexecuted instantiation: addresses.cpp:json_isspace(int)
Unexecuted instantiation: backup.cpp:json_isspace(int)
Unexecuted instantiation: coins.cpp:json_isspace(int)
Unexecuted instantiation: encrypt.cpp:json_isspace(int)
Unexecuted instantiation: spend.cpp:json_isspace(int)
Unexecuted instantiation: transactions.cpp:json_isspace(int)
Unexecuted instantiation: ipc_test.cpp:json_isspace(int)
Unexecuted instantiation: ipc_test.capnp.proxy-client.c++:json_isspace(int)
Unexecuted instantiation: ipc_test.capnp.proxy-types.c++:json_isspace(int)
Unexecuted instantiation: ipc_test.capnp.proxy-server.c++:json_isspace(int)
Unexecuted instantiation: init.capnp.proxy-client.c++:json_isspace(int)
Unexecuted instantiation: init.capnp.proxy-types.c++:json_isspace(int)
Unexecuted instantiation: mining.capnp.proxy-types.c++:json_isspace(int)
Unexecuted instantiation: rpc.capnp.proxy-types.c++:json_isspace(int)
Unexecuted instantiation: init.capnp.proxy-server.c++:json_isspace(int)
Unexecuted instantiation: mining.capnp.proxy-client.c++:json_isspace(int)
Unexecuted instantiation: mining.capnp.proxy-server.c++:json_isspace(int)
Unexecuted instantiation: rpc.capnp.proxy-client.c++:json_isspace(int)
Unexecuted instantiation: rpc.capnp.proxy-server.c++:json_isspace(int)
Unexecuted instantiation: args.cpp:json_isspace(int)
Unexecuted instantiation: config.cpp:json_isspace(int)
Unexecuted instantiation: run_command.cpp:json_isspace(int)
Unexecuted instantiation: settings.cpp:json_isspace(int)
Unexecuted instantiation: core_io.cpp:json_isspace(int)
Unexecuted instantiation: net_types.cpp:json_isspace(int)
Unexecuted instantiation: rawtransaction_util.cpp:json_isspace(int)
Unexecuted instantiation: request.cpp:json_isspace(int)
Unexecuted instantiation: univalue.cpp:json_isspace(int)
univalue_get.cpp:json_isspace(int)
Line
Count
Source
190
86
{
191
86
    switch (ch) {
192
0
    case 0x20:
193
0
    case 0x09:
194
0
    case 0x0a:
195
0
    case 0x0d:
196
0
        return true;
197
198
86
    default:
199
86
        return false;
200
86
    }
201
202
    // not reached
203
86
}
univalue_read.cpp:json_isspace(int)
Line
Count
Source
190
7.93M
{
191
7.93M
    switch (ch) {
192
1.78M
    case 0x20:
193
1.78M
    case 0x09:
194
1.80M
    case 0x0a:
195
1.80M
    case 0x0d:
196
1.80M
        return true;
197
198
6.12M
    default:
199
6.12M
        return false;
200
7.93M
    }
201
202
    // not reached
203
7.93M
}
Unexecuted instantiation: univalue_write.cpp:json_isspace(int)
204
205
extern const UniValue NullUniValue;
206
207
#endif // BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_H