from_chars: generalized chars to value

Read a value from the string, which must be trimmed to the value (ie, no leading/trailing whitespace). More...

Topics
	from_chars_first: generalized chars to value
	Read the first valid sequence of characters from the string, skipping leading whitespace, and convert it using from_chars: generalized chars to value .

Functions
bool	c4::from_chars (csubstr buf, uint8_t *v) noexcept
bool	c4::from_chars (csubstr buf, uint16_t *v) noexcept
bool	c4::from_chars (csubstr buf, uint32_t *v) noexcept
bool	c4::from_chars (csubstr buf, uint64_t *v) noexcept
bool	c4::from_chars (csubstr buf, int8_t *v) noexcept
bool	c4::from_chars (csubstr buf, int16_t *v) noexcept
bool	c4::from_chars (csubstr buf, int32_t *v) noexcept
bool	c4::from_chars (csubstr buf, int64_t *v) noexcept
bool	c4::from_chars (csubstr buf, float *v) noexcept
bool	c4::from_chars (csubstr buf, double *v) noexcept
template<class T>
auto	c4::from_chars (csubstr buf, T *v) noexcept -> bool::type
template<class T>
bool	c4::from_chars (csubstr buf, T **v) noexcept
bool	c4::from_chars (csubstr buf, bool *v) noexcept
bool	c4::from_chars (csubstr buf, char *v) noexcept
	extract a single character from a substring
bool	c4::from_chars (csubstr buf, csubstr *v) noexcept
bool	c4::from_chars (csubstr buf, substr *v) noexcept
template<class T>
bool	c4::from_chars (csubstr s, fmt::overflow_checked_< T > wrapper)
	read an integer type, detecting overflow (returns false on overflow)
template<class T>
bool	c4::from_chars (csubstr s, fmt::overflow_checked_< T > *wrapper)
	read an integer type, detecting overflow (returns false on overflow)
bool	c4::from_chars (csubstr buf, fmt::raw_wrapper *r)
	read a variable in raw binary format, using memcpy
bool	c4::from_chars (csubstr buf, fmt::raw_wrapper r)
	read a variable in raw binary format, using memcpy
bool	c4::from_chars (csubstr buf, fmt::base64_wrapper const &b)
	(1) read a variable in base64 format
bool	c4::from_chars (csubstr buf, fmt::base64_wrapper *b)
	(2) read a variable in base64 format
template<class T>
bool	c4::from_chars (csubstr buf, fmt::base64_container_wrapper< T > const &b)
	read a container in base64 format, resizing it as needed to accomodate the result
template<class T>
bool	c4::from_chars (csubstr buf, fmt::base64_container_wrapper< T > const *b)
	read a container in base64 format, resizing it as needed to accomodate the result

Detailed Description

Read a value from the string, which must be trimmed to the value (ie, no leading/trailing whitespace).

return true if the conversion succeeded. There is no check for overflow; the value wraps around in a way similar to the standard C/C++ overflow behavior. For example, from_chars<int8_t>("128", &val) returns true and val will be set tot 0. See overflows: does a number string overflow a type and Check read for overflow for facilities enforcing no-overflow.

Dispatches to the most appropriate and efficient conversion function

See also

from_chars_first: generalized chars to value, atou, atoi, atof, atod

Function Documentation

from_chars() [1/24]

bool c4::from_chars ( csubstr buf, uint8_t * v )

inlinenoexcept

Definition at line 2383 of file charconv.hpp.

{ return atou(buf, v); }

Referenced by from_chars(), from_chars(), from_chars(), from_chars_first(), from_chars_first(), from_chars_first(), c4::yml::from_chars_float(), c4::yml::from_chars_integral(), c4::yml::read(), c4::yml::read(), c4::yml::scalar_deserialize(), and uncatsep().

from_chars() [2/24]

bool c4::from_chars ( csubstr buf, uint16_t * v )

inlinenoexcept

Definition at line 2384 of file charconv.hpp.

{ return atou(buf, v); }

from_chars() [3/24]

bool c4::from_chars ( csubstr buf, uint32_t * v )

inlinenoexcept

Definition at line 2385 of file charconv.hpp.

{ return atou(buf, v); }

from_chars() [4/24]

bool c4::from_chars ( csubstr buf, uint64_t * v )

inlinenoexcept

Definition at line 2386 of file charconv.hpp.

{ return atou(buf, v); }

from_chars() [5/24]

bool c4::from_chars ( csubstr buf, int8_t * v )

inlinenoexcept

Definition at line 2387 of file charconv.hpp.

{ return atoi(buf, v); }

from_chars() [6/24]

bool c4::from_chars ( csubstr buf, int16_t * v )

inlinenoexcept

Definition at line 2388 of file charconv.hpp.

{ return atoi(buf, v); }

from_chars() [7/24]

bool c4::from_chars ( csubstr buf, int32_t * v )

inlinenoexcept

Definition at line 2389 of file charconv.hpp.

{ return atoi(buf, v); }

from_chars() [8/24]

bool c4::from_chars ( csubstr buf, int64_t * v )

inlinenoexcept

Definition at line 2390 of file charconv.hpp.

{ return atoi(buf, v); }

from_chars() [9/24]

bool c4::from_chars ( csubstr buf, float * v )

inlinenoexcept

Definition at line 2391 of file charconv.hpp.

{ return atof(buf, v); }

from_chars() [10/24]

bool c4::from_chars ( csubstr buf, double * v )

inlinenoexcept

Definition at line 2392 of file charconv.hpp.

{ return atod(buf, v); }

from_chars() [11/24]

template<class T>

auto c4::from_chars ( csubstr buf, T * v )->bool::type

inlinenoexcept

Definition at line 2394 of file charconv.hpp.

{ return atoi(buf, v); }

from_chars() [12/24]

template<class T>

bool c4::from_chars ( csubstr buf, T ** v )

inlinenoexcept

Definition at line 2397 of file charconv.hpp.

{ intptr_t tmp; bool ret = from_chars(buf, &tmp); if(ret) { *v = (T*)tmp; } return ret; }

from_chars() [13/24]

bool c4::from_chars ( csubstr buf, bool * v )

inlinenoexcept

Definition at line 2466 of file charconv.hpp.

{
    if(buf.len == 1)
    {
        if(buf.str[0] == '0')
        {
            *v = false; return true;
        }
        else if(buf.str[0] == '1')
        {
            *v = true; return true;
        }
    }
    else if(buf.len == 4)
    {
        if(((buf.str[0] == 't') && (0 == memcmp(buf.str + 1, "rue", 3)))
           ||
           ((buf.str[0] == 'T') && (0 == memcmp(buf.str + 1, "rue", 3) ||
                                    0 == memcmp(buf.str + 1, "RUE", 3))))
        {
            *v = true; return true;
        }
    }
    else if(buf.len == 5)
    {
        if(((buf.str[0] == 'f') && (0 == memcmp(buf.str + 1, "alse", 4)))
           ||
           ((buf.str[0] == 'F') && (0 == memcmp(buf.str + 1, "alse", 4) ||
                                    0 == memcmp(buf.str + 1, "ALSE", 4))))
        {
            *v = false; return true;
        }
    }
    // fallback to c-style int bools
    int val = 0;
    bool ret = from_chars(buf, &val);
    if C4_LIKELY(ret)
    {
        *v = (val != 0);
    }
    return ret;
}

from_chars() [14/24]

bool c4::from_chars ( csubstr buf, char * v )

inlinenoexcept

extract a single character from a substring

Note

to extract a string instead and not just a single character, use the csubstr overload

Definition at line 2537 of file charconv.hpp.

{
    if(buf.len != 1)
        return false;
    C4_XASSERT(buf.str);
    *v = buf.str[0];
    return true;
}

from_chars() [15/24]

bool c4::from_chars ( csubstr buf, csubstr * v )

inlinenoexcept

Definition at line 2577 of file charconv.hpp.

{
    *v = buf;
    return true;
}

from_chars() [16/24]

bool c4::from_chars ( csubstr buf, substr * v )

inlinenoexcept

Definition at line 2615 of file charconv.hpp.

{
    C4_ASSERT(!buf.overlaps(*v));
    // is the destination buffer wide enough?
    if(v->len >= buf.len)
    {
        // calling memcpy with zero len is undefined behavior
        // and will wreak havoc in calling code's branches.
        // see https://github.com/biojppm/rapidyaml/pull/264#issuecomment-1262133637
        if(buf.len)
        {
            C4_ASSERT(buf.str != nullptr);
            C4_ASSERT(v->str != nullptr);
            memcpy(v->str, buf.str, buf.len);
        }
        v->len = buf.len;
        return true;
    }
    return false;
}

from_chars() [17/24]

template<class T>

bool c4::from_chars ( csubstr s, fmt::overflow_checked_< T > wrapper )

inline

read an integer type, detecting overflow (returns false on overflow)

Definition at line 322 of file format.hpp.

{
    if C4_LIKELY(!overflows<T>(s))
        return atox(s, wrapper.val);
    return false;
}

from_chars() [18/24]

template<class T>

bool c4::from_chars ( csubstr s, fmt::overflow_checked_< T > * wrapper )

inline

read an integer type, detecting overflow (returns false on overflow)

Definition at line 331 of file format.hpp.

{
    if C4_LIKELY(!overflows<T>(s))
        return atox(s, wrapper->val);
    return false;
}

from_chars() [19/24]

bool c4::from_chars	(	csubstr	buf,
		fmt::raw_wrapper *	r )

read a variable in raw binary format, using memcpy

Definition at line 39 of file format.cpp.

{
    C4_SUPPRESS_WARNING_GCC_WITH_PUSH("-Wcast-qual")
    void * vptr = (void*)buf.str;
    C4_SUPPRESS_WARNING_GCC_POP
    size_t space = buf.len;
    char * ptr = (char*) std::align(r->alignment, r->len, vptr, space);
    C4_CHECK(ptr != nullptr);
    C4_CHECK(ptr >= buf.begin() && ptr <= buf.end());
    C4_SUPPRESS_WARNING_GCC_PUSH
    #if defined(__GNUC__) && __GNUC__ > 9
    C4_SUPPRESS_WARNING_GCC("-Wanalyzer-null-argument")
    #endif
    memcpy(r->buf, ptr, r->len);
    C4_SUPPRESS_WARNING_GCC_POP
    return true;
}

from_chars() [20/24]

bool c4::from_chars ( csubstr buf, fmt::raw_wrapper r )

inline

read a variable in raw binary format, using memcpy

Definition at line 465 of file format.hpp.

{
    return from_chars(buf, &r);
}

from_chars() [21/24]

bool c4::from_chars ( csubstr buf, fmt::base64_wrapper const & b )

inline

(1) read a variable in base64 format

Definition at line 219 of file format_base64.hpp.

{
    size_t reqsize = 0;
    bool ok = base64_decode(buf.str, buf.len, b.data.buf, b.data.len, &reqsize);
    if(b.required_size)
        *b.required_size = reqsize;
    return ok;
}

from_chars() [22/24]

bool c4::from_chars ( csubstr buf, fmt::base64_wrapper * b )

inline

(2) read a variable in base64 format

Definition at line 229 of file format_base64.hpp.

{
    return from_chars(buf, *b);
}

from_chars() [23/24]

template<class T>

bool c4::from_chars	(	csubstr	buf,
		fmt::base64_container_wrapper< T > const &	b )

read a container in base64 format, resizing it as needed to accomodate the result

Definition at line 261 of file format_base64.hpp.

{
    enum : size_t { elm_sz = sizeof(typename fmt::base64_container_wrapper<T>::value_type) }; // NOLINT
    blob data = b.data();
    size_t required_size = 0;
    bool ok = base64_decode(buf.str, buf.len, data.buf, data.len, &required_size);
    if(b.required_size)
        *b.required_size = required_size;
    if(!required_size)
        return ok;
    else if(!ok && ((required_size < data.len) || (required_size % elm_sz)))
        return false;
    size_t num_elms = required_size / elm_sz;
    b.container->resize(num_elms);
    if(required_size > data.len)
    {
        data = b.data();
        ok = base64_decode(buf.str, buf.len, data.buf, data.len, &required_size);
        if(b.required_size)
            *b.required_size = required_size;
    }
    return ok;
}

from_chars() [24/24]

template<class T>

bool c4::from_chars	(	csubstr	buf,
		fmt::base64_container_wrapper< T > const *	b )

read a container in base64 format, resizing it as needed to accomodate the result

Definition at line 288 of file format_base64.hpp.

{
    return from_chars(buf, *b);
}