boost_charconv 0.1.0

Boost C++ library boost_charconv packaged using Zanbil
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

# CharConv
This library is a C++11 compatible implementation of `<charconv>`. The full documentation can be found here: https://www.boost.org/doc/libs/master/libs/charconv/doc/html/charconv.html

# Build Status

|               | Master                                                                                                                                                                   | Develop                                                                                                                                                                |
|---------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Github Actions | [![CI](https://github.com/boostorg/charconv/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/boostorg/charconv/actions/workflows/ci.yml)      | [![Build Status](https://github.com/boostorg/charconv/workflows/CI/badge.svg?branch=develop)](https://github.com/boostorg/charconv/actions/workflows/ci.yml)     |
| Drone         | [![Build Status](https://drone.cpp.al/api/badges/boostorg/charconv/status.svg?ref=refs/heads/master)](https://drone.cpp.al/boostorg/charconv)                      | [![Build Status](https://drone.cpp.al/api/badges/boostorg/charconv/status.svg?ref=refs/heads/develop)](https://drone.cpp.al/boostorg/charconv)                   |
| Codecov       | [![codecov](https://codecov.io/gh/boostorg/charconv/branch/master/graph/badge.svg)](https://codecov.io/gh/boostorg/charconv/branch/master)                         | [![codecov](https://codecov.io/gh/boostorg/charconv/branch/develop/graph/badge.svg)](https://codecov.io/gh/boostorg/charconv/branch/develop)                     |
| Fuzzing | [![Fuzz](https://github.com/boostorg/charconv/actions/workflows/fuzz.yml/badge.svg?branch=master)](https://github.com/boostorg/charconv/actions/workflows/fuzz.yml) | [![Fuzz](https://github.com/boostorg/charconv/actions/workflows/fuzz.yml/badge.svg)](https://github.com/boostorg/charconv/actions/workflows/fuzz.yml)|

# How to build the library

## B2

````
git clone https://github.com/boostorg/boost
cd boost
git submodule update --init
cd ..
./bootstrap
./b2 cxxstd=11
````

This sets up a complete boost development and allows the tests to be run. To install the development environment run:

````
sudo ./b2 install cxxstd=11
````

# Synopsis

Charconv is a collection of parsing functions that are locale-independent, non-allocating, and non-throwing.

````
namespace boost { namespace charconv {

enum class chars_format : unsigned
{
    scientific = 1 << 0,
    fixed = 1 << 1,
    hex = 1 << 2,
    general = fixed | scientific
};

struct from_chars_result
{
    const char* ptr;
    std::errc ec;

    friend constexpr bool operator==(const from_chars_result& lhs, const from_chars_result& rhs) noexcept
    friend constexpr bool operator!=(const from_chars_result& lhs, const from_chars_result& rhs) noexcept
    constexpr explicit operator bool() const noexcept
}

template <typename Integral>
BOOST_CXX14_CONSTEXPR from_chars_result from_chars(const char* first, const char* last, Integral& value, int base = 10) noexcept;

BOOST_CXX14_CONSTEXPR from_chars_result from_chars<bool>(const char* first, const char* last, bool& value, int base) = delete;

template <typename Real>
from_chars_result from_chars(const char* first, const char* last, Real& value, chars_format fmt = chars_format::general) noexcept;

template <typename Real>
from_chars_result from_chars_erange(const char* first, const char* last, Real& value, chars_format fmt = chars_format::general) noexcept;

struct to_chars_result
{
    char* ptr;
    std::errc ec;

    friend constexpr bool operator==(const to_chars_result& lhs, const to_chars_result& rhs) noexcept;
    friend constexpr bool operator!=(const to_chars_result& lhs, const to_chars_result& rhs) noexcept;
    constexpr explicit operator bool() const noexcept
};

template <typename Integral>
BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars(char* first, char* last, Integral value, int base = 10) noexcept;

template <typename Integral>
BOOST_CHARCONV_CONSTEXPR to_chars_result to_chars<bool>(char* first, char* last, Integral value, int base) noexcept = delete;

template <typename Real>
to_chars_result to_chars(char* first, char* last, Real value, chars_format fmt = chars_format::general, int precision) noexcept;

}} // Namespace boost::charconv
````

## Notes
- `BOOST_CXX14_CONSTEXPR` is defined as `constexpr` when compiling with C++14 or newer.

- `BOOST_CHARCONV_CONSTEXPR` is defined as `constexpr` when compiling with C++14 or newer, and the compiler has `__builtin_is_constant_evaluated`

- For explanation of `from_chars_erange` see docs under heading: _Usage notes for from_chars for floating point types_

# Examples

## `from_chars`

````
const char* buffer = "42";
int v = 0;
from_chars_result r = boost::charconv::from_chars(buffer, buffer + std::strlen(buffer), v);
assert(r.ec == std::errc());
assert(r); // Equivalent to the above
assert(v == 42);

const char* buffer = "1.2345"
double v = 0;
auto r = boost::charconv::from_chars(buffer, buffer + std::strlen(buffer), v);
assert(r.ec == std::errc());
assert(v == 1.2345);

const char* buffer = "2a";
unsigned v = 0;
auto r = boost::charconv::from_chars(buffer, buffer + std::strlen(buffer), v, 16);
assert(r); // from_chars_result has operator bool()
assert(v == 42);

const char* buffer = "1.3a2bp-10";
double v = 0;
auto r = boost::charconv::from_chars(buffer, buffer + std::strlen(buffer), v, boost::charconv::chars_format::hex);
assert(r);
assert(v == 8.0427e-18);
````
## `to_chars`

````
char buffer[64] {};
int v = 42;
to_chars_result r = boost::charconv::to_chars(buffer, buffer + sizeof(buffer), v);
assert(r.ec == std::errc());
assert(!strcmp(buffer, "42")); // strcmp returns 0 on match

char buffer[64] {};
double v = 1e300;
to_chars_result r = boost::charconv::to_chars(buffer, buffer + sizeof(buffer), v);
assert(r.ec == std::errc());
assert(!strcmp(buffer, "1e+300"));

char buffer[64] {};
int v = 42;
to_chars_result r = boost::charconv::to_chars(buffer, buffer + sizeof(buffer), v, 16);
assert(r); // to_chars_result has operator bool()
assert(!strcmp(buffer, "2a")); // strcmp returns 0 on match

````