Coverage Report

Created: 2026-09-02 14:16

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
6.04M
    UniValue() { typ = VNULL; }
32
4.26M
    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.4M
    {
41
11.4M
        if constexpr (std::is_floating_point_v<T>) {
42
75.0k
            setFloat(val);
43
6.61M
        } else if constexpr (std::is_same_v<bool, T>) {
44
6.61M
            setBool(val);
45
6.61M
        } else if constexpr (std::is_signed_v<T>) {
46
790k
            setInt(int64_t{val});
47
1.01M
        } else if constexpr (std::is_unsigned_v<T>) {
48
1.01M
            setInt(uint64_t{val});
49
2.91M
        } else {
50
2.91M
            setStr(std::string{std::forward<Ref>(val)});
51
2.91M
        }
52
11.4M
    }
UniValue::UniValue<bool, bool, true>(bool&&)
Line
Count
Source
40
6.48M
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
6.48M
        } else if constexpr (std::is_same_v<bool, T>) {
44
6.48M
            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.48M
    }
UniValue::UniValue<char const (&) [1], char [1], true>(char const (&) [1])
Line
Count
Source
40
15.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
        } 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.9k
        } else {
50
15.9k
            setStr(std::string{std::forward<Ref>(val)});
51
15.9k
        }
52
15.9k
    }
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
204k
    {
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
204k
        } else {
50
204k
            setStr(std::string{std::forward<Ref>(val)});
51
204k
        }
52
204k
    }
UniValue::UniValue<char const (&) [10], char [10], true>(char const (&) [10])
Line
Count
Source
40
348
    {
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
348
        } else {
50
348
            setStr(std::string{std::forward<Ref>(val)});
51
348
        }
52
348
    }
UniValue::UniValue<char const (&) [6], char [6], true>(char const (&) [6])
Line
Count
Source
40
15.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
15.1k
        } else {
50
15.1k
            setStr(std::string{std::forward<Ref>(val)});
51
15.1k
        }
52
15.1k
    }
UniValue::UniValue<char const (&) [18], char [18], true>(char const (&) [18])
Line
Count
Source
40
2.51k
    {
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.51k
        } else {
50
2.51k
            setStr(std::string{std::forward<Ref>(val)});
51
2.51k
        }
52
2.51k
    }
UniValue::UniValue<char const (&) [3], char [3], true>(char const (&) [3])
Line
Count
Source
40
921
    {
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
921
        } else {
50
921
            setStr(std::string{std::forward<Ref>(val)});
51
921
        }
52
921
    }
UniValue::UniValue<char const (&) [5], char [5], true>(char const (&) [5])
Line
Count
Source
40
9.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
9.55k
        } else {
50
9.55k
            setStr(std::string{std::forward<Ref>(val)});
51
9.55k
        }
52
9.55k
    }
UniValue::UniValue<int, int, true>(int&&)
Line
Count
Source
40
318k
    {
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
318k
        } else if constexpr (std::is_signed_v<T>) {
46
318k
            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
318k
    }
UniValue::UniValue<double, double, true>(double&&)
Line
Count
Source
40
70.9k
    {
41
70.9k
        if constexpr (std::is_floating_point_v<T>) {
42
70.9k
            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
70.9k
    }
UniValue::UniValue<char const (&) [7], char [7], true>(char const (&) [7])
Line
Count
Source
40
8.59k
    {
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.59k
        } else {
50
8.59k
            setStr(std::string{std::forward<Ref>(val)});
51
8.59k
        }
52
8.59k
    }
UniValue::UniValue<unsigned long const&, unsigned long, true>(unsigned long const&)
Line
Count
Source
40
374k
    {
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
374k
        } else if constexpr (std::is_unsigned_v<T>) {
48
374k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
374k
    }
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.9k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
63.9k
        } else if constexpr (std::is_same_v<bool, T>) {
44
63.9k
            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.9k
    }
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.98M
    {
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.98M
        } else {
50
1.98M
            setStr(std::string{std::forward<Ref>(val)});
51
1.98M
        }
52
1.98M
    }
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
188k
    {
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
188k
        } else {
50
188k
            setStr(std::string{std::forward<Ref>(val)});
51
188k
        }
52
188k
    }
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
160
    {
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
160
        } else {
50
160
            setStr(std::string{std::forward<Ref>(val)});
51
160
        }
52
160
    }
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
263k
    {
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
263k
        } else {
50
263k
            setStr(std::string{std::forward<Ref>(val)});
51
263k
        }
52
263k
    }
UniValue::UniValue<int&, int, true>(int&)
Line
Count
Source
40
99.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
99.6k
        } else if constexpr (std::is_signed_v<T>) {
46
99.6k
            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
99.6k
    }
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.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
26.3k
        } else if constexpr (std::is_signed_v<T>) {
46
26.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
26.3k
    }
UniValue::UniValue<long&, long, true>(long&)
Line
Count
Source
40
21.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
21.7k
        } else if constexpr (std::is_signed_v<T>) {
46
21.7k
            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.7k
    }
UniValue::UniValue<bool&, bool, true>(bool&)
Line
Count
Source
40
65.0k
    {
41
        if constexpr (std::is_floating_point_v<T>) {
42
            setFloat(val);
43
65.0k
        } else if constexpr (std::is_same_v<bool, T>) {
44
65.0k
            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
65.0k
    }
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
181k
    {
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
181k
        } else {
50
181k
            setStr(std::string{std::forward<Ref>(val)});
51
181k
        }
52
181k
    }
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
89.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
89.6k
        } else if constexpr (std::is_signed_v<T>) {
46
89.6k
            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
89.6k
    }
UniValue::UniValue<long, long, true>(long&&)
Line
Count
Source
40
234k
    {
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
234k
        } else if constexpr (std::is_signed_v<T>) {
46
234k
            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
234k
    }
UniValue::UniValue<unsigned long, unsigned long, true>(unsigned long&&)
Line
Count
Source
40
62.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
        } else if constexpr (std::is_signed_v<T>) {
46
            setInt(int64_t{val});
47
62.5k
        } else if constexpr (std::is_unsigned_v<T>) {
48
62.5k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
62.5k
    }
UniValue::UniValue<char const (&) [26], char [26], true>(char const (&) [26])
Line
Count
Source
40
2.54k
    {
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.54k
        } else {
50
2.54k
            setStr(std::string{std::forward<Ref>(val)});
51
2.54k
        }
52
2.54k
    }
UniValue::UniValue<unsigned int&, unsigned int, true>(unsigned int&)
Line
Count
Source
40
19.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
19.1k
        } else if constexpr (std::is_unsigned_v<T>) {
48
19.1k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
19.1k
    }
UniValue::UniValue<unsigned long&, unsigned long, true>(unsigned long&)
Line
Count
Source
40
81.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
81.1k
        } else if constexpr (std::is_unsigned_v<T>) {
48
81.1k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
81.1k
    }
UniValue::UniValue<char const (&) [11], char [11], true>(char const (&) [11])
Line
Count
Source
40
4.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
4.40k
        } else {
50
4.40k
            setStr(std::string{std::forward<Ref>(val)});
51
4.40k
        }
52
4.40k
    }
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
94
    {
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
94
        } else {
50
94
            setStr(std::string{std::forward<Ref>(val)});
51
94
        }
52
94
    }
UniValue::UniValue<char const (&) [15], char [15], true>(char const (&) [15])
Line
Count
Source
40
992
    {
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
992
        } else {
50
992
            setStr(std::string{std::forward<Ref>(val)});
51
992
        }
52
992
    }
UniValue::UniValue<char const (&) [87], char [87], true>(char const (&) [87])
Line
Count
Source
40
2.54k
    {
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.54k
        } else {
50
2.54k
            setStr(std::string{std::forward<Ref>(val)});
51
2.54k
        }
52
2.54k
    }
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
20.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
20.2k
        } else if constexpr (std::is_unsigned_v<T>) {
48
20.2k
            setInt(uint64_t{val});
49
        } else {
50
            setStr(std::string{std::forward<Ref>(val)});
51
        }
52
20.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
216
    {
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
216
        } else {
50
216
            setStr(std::string{std::forward<Ref>(val)});
51
216
        }
52
216
    }
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.86k
    {
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.86k
        } else {
50
3.86k
            setStr(std::string{std::forward<Ref>(val)});
51
3.86k
        }
52
3.86k
    }
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
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.74k
    {
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.74k
        } else {
50
7.74k
            setStr(std::string{std::forward<Ref>(val)});
51
7.74k
        }
52
7.74k
    }
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.73k
    {
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.73k
        } else {
50
4.73k
            setStr(std::string{std::forward<Ref>(val)});
51
4.73k
        }
52
4.73k
    }
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.76k
    {
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.76k
        } else {
50
1.76k
            setStr(std::string{std::forward<Ref>(val)});
51
1.76k
        }
52
1.76k
    }
UniValue::UniValue<char const (&) [45], char [45], true>(char const (&) [45])
Line
Count
Source
40
354
    {
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
354
        } else {
50
354
            setStr(std::string{std::forward<Ref>(val)});
51
354
        }
52
354
    }
UniValue::UniValue<char const (&) [86], char [86], true>(char const (&) [86])
Line
Count
Source
40
238
    {
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
238
        } else {
50
238
            setStr(std::string{std::forward<Ref>(val)});
51
238
        }
52
238
    }
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
19.0M
    enum VType getType() const { return typ; }
68
1.59M
    const std::string& getValStr() const { return val; }
69
1.42M
    bool empty() const { return (values.size() == 0); }
70
71
2.06M
    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
237k
    bool exists(const std::string& key) const { size_t i; return findKey(key, i); }
80
81
2.50M
    bool isNull() const { return (typ == VNULL); }
82
6.04M
    bool isTrue() const { return (typ == VBOOL) && (val == "1"); }
83
2.30M
    bool isFalse() const { return (typ == VBOOL) && (val != "1"); }
84
253k
    bool isBool() const { return (typ == VBOOL); }
85
447k
    bool isStr() const { return (typ == VSTR); }
86
139k
    bool isNum() const { return (typ == VNUM); }
87
312k
    bool isArray() const { return (typ == VARR); }
88
710k
    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.3k
    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
233
{
138
233
    checkType(VARR);
139
233
    values.insert(values.end(), first, last);
140
233
}
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
138
{
138
138
    checkType(VARR);
139
138
    values.insert(values.end(), first, last);
140
138
}
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.24k
{
145
8.24k
    static_assert(std::is_integral_v<Int>);
146
8.24k
    checkType(VNUM);
147
8.24k
    Int result;
148
8.24k
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
149
8.24k
    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.24k
    return result;
153
8.24k
}
unsigned long UniValue::getInt<unsigned long>() const
Line
Count
Source
144
829
{
145
829
    static_assert(std::is_integral_v<Int>);
146
829
    checkType(VNUM);
147
829
    Int result;
148
829
    const auto [first_nonmatching, error_condition] = std::from_chars(val.data(), val.data() + val.size(), result);
149
829
    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
829
    return result;
153
829
}
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.85M
{
177
4.85M
    switch (jtt) {
178
794
    case JTOK_KW_NULL:
179
17.6k
    case JTOK_KW_TRUE:
180
20.0k
    case JTOK_KW_FALSE:
181
319k
    case JTOK_NUMBER:
182
2.03M
    case JTOK_STRING:
183
2.03M
        return true;
184
185
2.82M
    default:
186
2.82M
        return false;
187
4.85M
    }
188
189
    // not reached
190
4.85M
}
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.85M
{
177
4.85M
    switch (jtt) {
178
794
    case JTOK_KW_NULL:
179
17.6k
    case JTOK_KW_TRUE:
180
20.0k
    case JTOK_KW_FALSE:
181
319k
    case JTOK_NUMBER:
182
2.03M
    case JTOK_STRING:
183
2.03M
        return true;
184
185
2.82M
    default:
186
2.82M
        return false;
187
4.85M
    }
188
189
    // not reached
190
4.85M
}
Unexecuted instantiation: univalue_write.cpp:jsonTokenIsValue(jtokentype)
191
192
static inline bool json_isspace(int ch)
193
8.69M
{
194
8.69M
    switch (ch) {
195
1.93M
    case 0x20:
196
1.93M
    case 0x09:
197
1.95M
    case 0x0a:
198
1.95M
    case 0x0d:
199
1.95M
        return true;
200
201
6.74M
    default:
202
6.74M
        return false;
203
8.69M
    }
204
205
    // not reached
206
8.69M
}
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.69M
{
194
8.69M
    switch (ch) {
195
1.93M
    case 0x20:
196
1.93M
    case 0x09:
197
1.95M
    case 0x0a:
198
1.95M
    case 0x0d:
199
1.95M
        return true;
200
201
6.74M
    default:
202
6.74M
        return false;
203
8.69M
    }
204
205
    // not reached
206
8.69M
}
Unexecuted instantiation: univalue_write.cpp:json_isspace(int)
207
208
extern const UniValue NullUniValue;
209
210
#endif // BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_H