Coverage Report

Created: 2026-09-14 20:36

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 (c) 2015-present The 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.96M
    UniValue() { typ = VNULL; }
32
4.21M
    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
11.1M
    {
41
11.1M
        if constexpr (std::is_floating_point_v<T>) {
42
70.9k
            setFloat(val);
43
6.48M
        } else if constexpr (std::is_same_v<bool, T>) {
44
6.48M
            setBool(val);
45
6.48M
        } else if constexpr (std::is_signed_v<T>) {
46
770k
            setInt(int64_t{val});
47
1.00M
        } else if constexpr (std::is_unsigned_v<T>) {
48
1.00M
            setInt(uint64_t{val});
49
2.84M
        } else {
50
2.84M
            setStr(std::string{std::forward<Ref>(val)});
51
2.84M
        }
52
11.1M
    }
UniValue::UniValue<bool, bool, true>(bool&&)
Line
Count
Source
40
6.36M
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
6.36M
        } else if constexpr (std::is_same_v<bool, T>) {
44
6.36M
            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
6.36M
    }
UniValue::UniValue<char const (&) [1], char [1], true>(char const (&) [1])
Line
Count
Source
40
16.0k
    {
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.0k
        } else {
50
16.0k
            setStr(std::string{std::forward<Ref>(val)});
51
16.0k
        }
52
16.0k
    }
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
201k
    {
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
201k
        } else {
50
201k
            setStr(std::string{std::forward<Ref>(val)});
51
201k
        }
52
201k
    }
UniValue::UniValue<char const (&) [10], char [10], true>(char const (&) [10])
Line
Count
Source
40
349
    {
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
349
        } else {
50
349
            setStr(std::string{std::forward<Ref>(val)});
51
349
        }
52
349
    }
UniValue::UniValue<char const (&) [6], char [6], true>(char const (&) [6])
Line
Count
Source
40
15.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
        } 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.3k
        } else {
50
15.3k
            setStr(std::string{std::forward<Ref>(val)});
51
15.3k
        }
52
15.3k
    }
UniValue::UniValue<char const (&) [18], char [18], true>(char const (&) [18])
Line
Count
Source
40
2.53k
    {
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.53k
        } else {
50
2.53k
            setStr(std::string{std::forward<Ref>(val)});
51
2.53k
        }
52
2.53k
    }
UniValue::UniValue<char const (&) [3], char [3], true>(char const (&) [3])
Line
Count
Source
40
929
    {
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
929
        } else {
50
929
            setStr(std::string{std::forward<Ref>(val)});
51
929
        }
52
929
    }
UniValue::UniValue<char const (&) [5], char [5], true>(char const (&) [5])
Line
Count
Source
40
9.66k
    {
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.66k
        } else {
50
9.66k
            setStr(std::string{std::forward<Ref>(val)});
51
9.66k
        }
52
9.66k
    }
UniValue::UniValue<int, int, true>(int&&)
Line
Count
Source
40
315k
    {
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
315k
        } else if constexpr (std::is_signed_v<T>) {
46
315k
            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
315k
    }
UniValue::UniValue<double, double, true>(double&&)
Line
Count
Source
40
66.8k
    {
41
66.8k
        if constexpr (std::is_floating_point_v<T>) {
42
66.8k
            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
66.8k
    }
UniValue::UniValue<char const (&) [7], char [7], true>(char const (&) [7])
Line
Count
Source
40
8.62k
    {
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.62k
        } else {
50
8.62k
            setStr(std::string{std::forward<Ref>(val)});
51
8.62k
        }
52
8.62k
    }
UniValue::UniValue<unsigned long const&, unsigned long, true>(unsigned long const&)
Line
Count
Source
40
371k
    {
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
371k
        } else if constexpr (std::is_unsigned_v<T>) {
48
371k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
371k
    }
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
63.3k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
63.3k
        } else if constexpr (std::is_same_v<bool, T>) {
44
63.3k
            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.3k
    }
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.92M
    {
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.92M
        } else {
50
1.92M
            setStr(std::string{std::forward<Ref>(val)});
51
1.92M
        }
52
1.92M
    }
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
190k
    {
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
190k
        } else {
50
190k
            setStr(std::string{std::forward<Ref>(val)});
51
190k
        }
52
190k
    }
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
172
    {
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
172
        } else {
50
172
            setStr(std::string{std::forward<Ref>(val)});
51
172
        }
52
172
    }
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
264k
    {
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
264k
        } else {
50
264k
            setStr(std::string{std::forward<Ref>(val)});
51
264k
        }
52
264k
    }
UniValue::UniValue<int&, int, true>(int&)
Line
Count
Source
40
97.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
97.2k
        } else if constexpr (std::is_signed_v<T>) {
46
97.2k
            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
97.2k
    }
UniValue::UniValue<unsigned int const&, unsigned int, true>(unsigned int const&)
Line
Count
Source
40
430k
    {
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
430k
        } else if constexpr (std::is_unsigned_v<T>) {
48
430k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
430k
    }
UniValue::UniValue<long const&, long, true>(long const&)
Line
Count
Source
40
26.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
26.2k
        } else if constexpr (std::is_signed_v<T>) {
46
26.2k
            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
26.2k
    }
UniValue::UniValue<long&, long, true>(long&)
Line
Count
Source
40
21.5k
    {
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
21.5k
        } else if constexpr (std::is_signed_v<T>) {
46
21.5k
            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
21.5k
    }
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
179k
    {
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
179k
        } else {
50
179k
            setStr(std::string{std::forward<Ref>(val)});
51
179k
        }
52
179k
    }
UniValue::UniValue<char const (&) [8], char [8], true>(char const (&) [8])
Line
Count
Source
40
1.70k
    {
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.70k
        } else {
50
1.70k
            setStr(std::string{std::forward<Ref>(val)});
51
1.70k
        }
52
1.70k
    }
UniValue::UniValue<int const&, int, true>(int const&)
Line
Count
Source
40
82.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
82.4k
        } else if constexpr (std::is_signed_v<T>) {
46
82.4k
            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
82.4k
    }
UniValue::UniValue<long, long, true>(long&&)
Line
Count
Source
40
227k
    {
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
227k
        } else if constexpr (std::is_signed_v<T>) {
46
227k
            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
227k
    }
UniValue::UniValue<unsigned long, unsigned long, true>(unsigned long&&)
Line
Count
Source
40
60.7k
    {
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
60.7k
        } else if constexpr (std::is_unsigned_v<T>) {
48
60.7k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
60.7k
    }
UniValue::UniValue<char const (&) [26], char [26], true>(char const (&) [26])
Line
Count
Source
40
2.56k
    {
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.56k
        } else {
50
2.56k
            setStr(std::string{std::forward<Ref>(val)});
51
2.56k
        }
52
2.56k
    }
UniValue::UniValue<unsigned int&, unsigned int, true>(unsigned int&)
Line
Count
Source
40
19.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
19.2k
        } else if constexpr (std::is_unsigned_v<T>) {
48
19.2k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
19.2k
    }
UniValue::UniValue<unsigned long&, unsigned long, true>(unsigned long&)
Line
Count
Source
40
77.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
77.1k
        } else if constexpr (std::is_unsigned_v<T>) {
48
77.1k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
77.1k
    }
UniValue::UniValue<char const (&) [11], char [11], true>(char const (&) [11])
Line
Count
Source
40
4.44k
    {
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.44k
        } else {
50
4.44k
            setStr(std::string{std::forward<Ref>(val)});
51
4.44k
        }
52
4.44k
    }
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
5
    {
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
        } else {
50
5
            setStr(std::string{std::forward<Ref>(val)});
51
5
        }
52
5
    }
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
95
    {
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
95
        } else {
50
95
            setStr(std::string{std::forward<Ref>(val)});
51
95
        }
52
95
    }
UniValue::UniValue<char const (&) [15], char [15], true>(char const (&) [15])
Line
Count
Source
40
998
    {
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
998
        } else {
50
998
            setStr(std::string{std::forward<Ref>(val)});
51
998
        }
52
998
    }
UniValue::UniValue<char const (&) [87], char [87], true>(char const (&) [87])
Line
Count
Source
40
2.55k
    {
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.55k
        } else {
50
2.55k
            setStr(std::string{std::forward<Ref>(val)});
51
2.55k
        }
52
2.55k
    }
UniValue::UniValue<char const (&) [22], char [22], true>(char const (&) [22])
Line
Count
Source
40
10
    {
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
10
        } else {
50
10
            setStr(std::string{std::forward<Ref>(val)});
51
10
        }
52
10
    }
UniValue::UniValue<unsigned int, unsigned int, true>(unsigned int&&)
Line
Count
Source
40
19.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
19.2k
        } else if constexpr (std::is_unsigned_v<T>) {
48
19.2k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
19.2k
    }
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
1.09k
    {
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.09k
        } else {
50
1.09k
            setStr(std::string{std::forward<Ref>(val)});
51
1.09k
        }
52
1.09k
    }
UniValue::UniValue<char const (&) [13], char [13], true>(char const (&) [13])
Line
Count
Source
40
217
    {
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
217
        } else {
50
217
            setStr(std::string{std::forward<Ref>(val)});
51
217
        }
52
217
    }
Unexecuted instantiation: UniValue::UniValue<char const*, char const*, true>(char const*&&)
UniValue::UniValue<double const&, double, true>(double const&)
Line
Count
Source
40
3.80k
    {
41
3.80k
        if constexpr (std::is_floating_point_v<T>) {
42
3.80k
            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
3.80k
    }
UniValue::UniValue<unsigned short const&, unsigned short, true>(unsigned short const&)
Line
Count
Source
40
5
    {
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
5
        } else if constexpr (std::is_unsigned_v<T>) {
48
5
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
5
    }
UniValue::UniValue<char const (&) [21], char [21], true>(char const (&) [21])
Line
Count
Source
40
3.77k
    {
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.77k
        } else {
50
3.77k
            setStr(std::string{std::forward<Ref>(val)});
51
3.77k
        }
52
3.77k
    }
UniValue::UniValue<unsigned short, unsigned short, true>(unsigned short&&)
Line
Count
Source
40
27.7k
    {
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.7k
        } else if constexpr (std::is_unsigned_v<T>) {
48
27.7k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
27.7k
    }
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
762
    {
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
762
        } else if constexpr (std::is_unsigned_v<T>) {
48
762
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
762
    }
UniValue::UniValue<char const (&) [35], char [35], true>(char const (&) [35])
Line
Count
Source
40
7.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
7.80k
        } else {
50
7.80k
            setStr(std::string{std::forward<Ref>(val)});
51
7.80k
        }
52
7.80k
    }
UniValue::UniValue<char const (&) [46], char [46], true>(char const (&) [46])
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
        } else if constexpr (std::is_unsigned_v<T>) {
48
            setInt(uint64_t{val});
49
4
        } else {
50
4
            setStr(std::string{std::forward<Ref>(val)});
51
4
        }
52
4
    }
UniValue::UniValue<char const (&) [12], char [12], true>(char const (&) [12])
Line
Count
Source
40
4.78k
    {
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.78k
        } else {
50
4.78k
            setStr(std::string{std::forward<Ref>(val)});
51
4.78k
        }
52
4.78k
    }
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
18
    {
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
        } else if constexpr (std::is_unsigned_v<T>) {
48
18
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
18
    }
UniValue::UniValue<char const (&) [29], char [29], true>(char const (&) [29])
Line
Count
Source
40
1.78k
    {
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.78k
        } else {
50
1.78k
            setStr(std::string{std::forward<Ref>(val)});
51
1.78k
        }
52
1.78k
    }
UniValue::UniValue<char const (&) [45], char [45], true>(char const (&) [45])
Line
Count
Source
40
356
    {
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
356
        } else {
50
356
            setStr(std::string{std::forward<Ref>(val)});
51
356
        }
52
356
    }
UniValue::UniValue<char const (&) [86], char [86], true>(char const (&) [86])
Line
Count
Source
40
240
    {
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
240
        } else {
50
240
            setStr(std::string{std::forward<Ref>(val)});
51
240
        }
52
240
    }
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
17
    {
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
17
        } else {
50
17
            setStr(std::string{std::forward<Ref>(val)});
51
17
        }
52
17
    }
UniValue::UniValue<char const (&) [33], char [33], true>(char const (&) [33])
Line
Count
Source
40
30
    {
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
30
        } else {
50
30
            setStr(std::string{std::forward<Ref>(val)});
51
30
        }
52
30
    }
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
18.6M
    enum VType getType() const { return typ; }
68
1.58M
    const std::string& getValStr() const { return val; }
69
1.40M
    bool empty() const { return (values.size() == 0); }
70
71
1.99M
    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
234k
    bool exists(const std::string& key) const { size_t i; return findKey(key, i); }
80
81
2.49M
    bool isNull() const { return (typ == VNULL); }
82
5.92M
    bool isTrue() const { return (typ == VBOOL) && (val == "1"); }
83
2.30M
    bool isFalse() const { return (typ == VBOOL) && (val != "1"); }
84
250k
    bool isBool() const { return (typ == VBOOL); }
85
442k
    bool isStr() const { return (typ == VSTR); }
86
140k
    bool isNum() const { return (typ == VNUM); }
87
309k
    bool isArray() const { return (typ == VARR); }
88
699k
    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
    /// Parse JSON; set value to null on failure.
103
    [[nodiscard]] bool read(std::string_view json);
104
105
private:
106
    UniValue::VType typ;
107
    std::string val;                       // numbers are stored as C++ strings
108
    std::vector<std::string> keys;
109
    std::vector<UniValue> values;
110
111
    void checkType(const VType& expected) const;
112
    bool findKey(const std::string& key, size_t& retIdx) const;
113
    void writeArray(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const;
114
    void writeObject(unsigned int prettyIndent, unsigned int indentLevel, std::string& s) const;
115
    /// Internal parser: May leave this value in an invalid state on failure.
116
    [[nodiscard]] bool read_impl(std::string_view str_in);
117
118
public:
119
    // Strict type-specific getters, these throw std::runtime_error if the
120
    // value is of unexpected type
121
    const std::vector<std::string>& getKeys() const;
122
    const std::vector<UniValue>& getValues() const;
123
    template <typename Int>
124
    Int getInt() const;
125
    bool get_bool() const;
126
    const std::string& get_str() const;
127
    double get_real() const;
128
    const UniValue& get_obj() const;
129
    const UniValue& get_array() const;
130
131
20.4k
    enum VType type() const { return getType(); }
132
    const UniValue& find_value(std::string_view key) const;
133
};
134
135
template <class It>
136
void UniValue::push_backV(It first, It last)
137
235
{
138
235
    checkType(VARR);
139
235
    values.insert(values.end(), first, last);
140
235
}
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
137
95
{
138
95
    checkType(VARR);
139
95
    values.insert(values.end(), first, last);
140
95
}
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
137
140
{
138
140
    checkType(VARR);
139
140
    values.insert(values.end(), first, last);
140
140
}
141
142
template <typename Int>
143
Int UniValue::getInt() const
144
64.9k
{
145
64.9k
    static_assert(std::is_integral_v<Int>);
146
64.9k
    checkType(VNUM);
147
64.9k
    Int result;
148
64.9k
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
149
64.9k
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
150
9
        throw std::runtime_error("JSON integer out of range");
151
9
    }
152
64.9k
    return result;
153
64.9k
}
int UniValue::getInt<int>() const
Line
Count
Source
144
22.4k
{
145
22.4k
    static_assert(std::is_integral_v<Int>);
146
22.4k
    checkType(VNUM);
147
22.4k
    Int result;
148
22.4k
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
149
22.4k
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
150
1
        throw std::runtime_error("JSON integer out of range");
151
1
    }
152
22.4k
    return result;
153
22.4k
}
long UniValue::getInt<long>() const
Line
Count
Source
144
8.25k
{
145
8.25k
    static_assert(std::is_integral_v<Int>);
146
8.25k
    checkType(VNUM);
147
8.25k
    Int result;
148
8.25k
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
149
8.25k
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
150
2
        throw std::runtime_error("JSON integer out of range");
151
2
    }
152
8.25k
    return result;
153
8.25k
}
unsigned long UniValue::getInt<unsigned long>() const
Line
Count
Source
144
834
{
145
834
    static_assert(std::is_integral_v<Int>);
146
834
    checkType(VNUM);
147
834
    Int result;
148
834
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
149
834
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
150
0
        throw std::runtime_error("JSON integer out of range");
151
0
    }
152
834
    return result;
153
834
}
unsigned int UniValue::getInt<unsigned int>() const
Line
Count
Source
144
1.04k
{
145
1.04k
    static_assert(std::is_integral_v<Int>);
146
1.04k
    checkType(VNUM);
147
1.04k
    Int result;
148
1.04k
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
149
1.04k
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
150
1
        throw std::runtime_error("JSON integer out of range");
151
1
    }
152
1.04k
    return result;
153
1.04k
}
unsigned short UniValue::getInt<unsigned short>() const
Line
Count
Source
144
32.3k
{
145
32.3k
    static_assert(std::is_integral_v<Int>);
146
32.3k
    checkType(VNUM);
147
32.3k
    Int result;
148
32.3k
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
149
32.3k
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
150
4
        throw std::runtime_error("JSON integer out of range");
151
4
    }
152
32.3k
    return result;
153
32.3k
}
signed char UniValue::getInt<signed char>() const
Line
Count
Source
144
1
{
145
1
    static_assert(std::is_integral_v<Int>);
146
1
    checkType(VNUM);
147
1
    Int result;
148
1
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
149
1
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
150
0
        throw std::runtime_error("JSON integer out of range");
151
0
    }
152
1
    return result;
153
1
}
unsigned char UniValue::getInt<unsigned char>() const
Line
Count
Source
144
1
{
145
1
    static_assert(std::is_integral_v<Int>);
146
1
    checkType(VNUM);
147
1
    Int result;
148
1
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
149
1
    if (first_nonmatching != val.data() + val.size() || error_condition != std::errc{}) {
150
1
        throw std::runtime_error("JSON integer out of range");
151
1
    }
152
0
    return result;
153
1
}
Unexecuted instantiation: short UniValue::getInt<short>() const
154
155
enum jtokentype {
156
    JTOK_ERR        = -1,
157
    JTOK_NONE       = 0,                           // eof
158
    JTOK_OBJ_OPEN,
159
    JTOK_OBJ_CLOSE,
160
    JTOK_ARR_OPEN,
161
    JTOK_ARR_CLOSE,
162
    JTOK_COLON,
163
    JTOK_COMMA,
164
    JTOK_KW_NULL,
165
    JTOK_KW_TRUE,
166
    JTOK_KW_FALSE,
167
    JTOK_NUMBER,
168
    JTOK_STRING,
169
};
170
171
extern enum jtokentype getJsonToken(std::string& tokenVal,
172
                                    unsigned int& consumed, const char *raw, const char *end);
173
extern const char *uvTypeName(UniValue::VType t);
174
175
static inline bool jsonTokenIsValue(enum jtokentype jtt)
176
4.80M
{
177
4.80M
    switch (jtt) {
178
794
    case JTOK_KW_NULL:
179
16.8k
    case JTOK_KW_TRUE:
180
19.2k
    case JTOK_KW_FALSE:
181
316k
    case JTOK_NUMBER:
182
2.01M
    case JTOK_STRING:
183
2.01M
        return true;
184
185
2.79M
    default:
186
2.79M
        return false;
187
4.80M
    }
188
189
    // not reached
190
4.80M
}
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: hash_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: ipc_test.capnp.proxy-client.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: ipc_test.capnp.proxy-server.c++:jsonTokenIsValue(jtokentype)
Unexecuted instantiation: ipc_test.capnp.proxy-types.c++: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: 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
176
4.80M
{
177
4.80M
    switch (jtt) {
178
794
    case JTOK_KW_NULL:
179
16.8k
    case JTOK_KW_TRUE:
180
19.2k
    case JTOK_KW_FALSE:
181
316k
    case JTOK_NUMBER:
182
2.01M
    case JTOK_STRING:
183
2.01M
        return true;
184
185
2.79M
    default:
186
2.79M
        return false;
187
4.80M
    }
188
189
    // not reached
190
4.80M
}
Unexecuted instantiation: univalue_write.cpp:jsonTokenIsValue(jtokentype)
191
192
static inline bool json_isspace(int ch)
193
8.58M
{
194
8.58M
    switch (ch) {
195
1.91M
    case 0x20:
196
1.91M
    case 0x09:
197
1.93M
    case 0x0a:
198
1.93M
    case 0x0d:
199
1.93M
        return true;
200
201
6.65M
    default:
202
6.65M
        return false;
203
8.58M
    }
204
205
    // not reached
206
8.58M
}
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: hash_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: ipc_test.capnp.proxy-client.c++:json_isspace(int)
Unexecuted instantiation: ipc_test.capnp.proxy-server.c++:json_isspace(int)
Unexecuted instantiation: ipc_test.capnp.proxy-types.c++: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: 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
193
86
{
194
86
    switch (ch) {
195
0
    case 0x20:
196
0
    case 0x09:
197
0
    case 0x0a:
198
0
    case 0x0d:
199
0
        return true;
200
201
86
    default:
202
86
        return false;
203
86
    }
204
205
    // not reached
206
86
}
univalue_read.cpp:json_isspace(int)
Line
Count
Source
193
8.58M
{
194
8.58M
    switch (ch) {
195
1.91M
    case 0x20:
196
1.91M
    case 0x09:
197
1.93M
    case 0x0a:
198
1.93M
    case 0x0d:
199
1.93M
        return true;
200
201
6.65M
    default:
202
6.65M
        return false;
203
8.58M
    }
204
205
    // not reached
206
8.58M
}
Unexecuted instantiation: univalue_write.cpp:json_isspace(int)
207
208
extern const UniValue NullUniValue;
209
210
#endif // BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_H