LexicalCast.h

#pragma once
 
#include <xrpl/beast/utility/instrumentation.h>
 
#include <boost/core/detail/string_view.hpp>
 
#include <algorithm>
#include <cctype>
#include <charconv>
#include <iterator>
#include <string>
#include <string_view>
#include <system_error>
#include <type_traits>
#include <typeinfo>
 
namespace beast {
 
namespace detail {
 
// These specializations get called by the non-member functions to do the work
template <class Out, class In>
struct LexicalCast;
 
// conversion to std::string
template <class In>
struct LexicalCast<std::string, In>
{
    explicit LexicalCast() = default;
 
    template <class Arithmetic = In>
    bool
    operator()(std::string& out, Arithmetic in)
        requires(std::is_arithmetic_v<Arithmetic>)
    {
        out = std::to_string(in);
        return true;
    }
 
    template <class Enumeration = In>
    bool
    operator()(std::string& out, Enumeration in)
        requires(std::is_enum_v<Enumeration>)
    {
        out = std::to_string(static_cast<std::underlying_type_t<Enumeration>>(in));
        return true;
    }
};
 
// Parse a std::string_view into a number
template <typename Out>
struct LexicalCast<Out, std::string_view>
{
    explicit LexicalCast() = default;
 
    static_assert(
        std::is_integral_v<Out>,
        "beast::LexicalCast can only be used with integral types");
 
    template <class Integral = Out>
    constexpr bool
    operator()(Integral& out, std::string_view in) const
        requires(std::is_integral_v<Integral> && !std::is_same_v<Integral, bool>)
    {
        auto first = in.data();
        auto last = in.data() + in.size();
 
        if (first != last && *first == '+')
            ++first;
 
        auto ret = std::from_chars(first, last, out);
 
        return ret.ec == std::errc() && ret.ptr == last;
    }
 
    bool
    operator()(bool& out, std::string_view in) const
    {
        std::string result;
 
        // Convert the input to lowercase
        std::transform(in.begin(), in.end(), std::back_inserter(result), [](auto c) {
            return std::tolower(static_cast<unsigned char>(c));
        });
 
        if (result == "1" || result == "true")
        {
            out = true;
            return true;
        }
 
        if (result == "0" || result == "false")
        {
            out = false;
            return true;
        }
 
        return false;
    }
};
//------------------------------------------------------------------------------
 
// Parse boost library's string_view to number or boolean value
// Note: As of Jan 2024, Boost contains three different types of string_view
// (boost::core::basic_string_view<char>, boost::string_ref and
// boost::string_view). The below template specialization is included because
// it is used in the handshake.cpp file
template <class Out>
struct LexicalCast<Out, boost::core::basic_string_view<char>>
{
    explicit LexicalCast() = default;
 
    constexpr bool
    operator()(Out& out, boost::core::basic_string_view<char> in) const
    {
        return LexicalCast<Out, std::string_view>()(out, in);
    }
};
 
// Parse std::string to number or boolean value
template <class Out>
struct LexicalCast<Out, std::string>
{
    explicit LexicalCast() = default;
 
    constexpr bool
    operator()(Out& out, std::string in) const
    {
        return LexicalCast<Out, std::string_view>()(out, in);
    }
};
 
// Conversion from null terminated char const*
template <class Out>
struct LexicalCast<Out, char const*>
{
    explicit LexicalCast() = default;
 
    constexpr bool
    operator()(Out& out, char const* in) const
    {
        XRPL_ASSERT(in, "beast::detail::LexicalCast(char const*) : non-null input");
        return LexicalCast<Out, std::string_view>()(out, in);
    }
};
 
// Conversion from null terminated char*
// The string is not modified.
template <class Out>
struct LexicalCast<Out, char*>
{
    explicit LexicalCast() = default;
 
    constexpr bool
    operator()(Out& out, char* in) const
    {
        XRPL_ASSERT(in, "beast::detail::LexicalCast(char*) : non-null input");
        return LexicalCast<Out, std::string_view>()(out, in);
    }
};
 
}  // namespace detail
 
//------------------------------------------------------------------------------

struct BadLexicalCast : public std::bad_cast
{
    explicit BadLexicalCast() = default;
};

template <class Out, class In>
constexpr bool
lexicalCastChecked(Out& out, In in)
{
    return detail::LexicalCast<Out, In>()(out, in);
}

template <class Out, class In>
constexpr Out
lexicalCastThrow(In in)
{
    if (Out out; lexicalCastChecked(out, in))
        return out;
 
    throw BadLexicalCast();
}

template <class Out, class In>
constexpr Out
lexicalCast(In in, Out defaultValue = Out())
{
    if (Out out; lexicalCastChecked(out, in))
        return out;
 
    return defaultValue;
}
 
}  // namespace beast