NumberParser.hpp

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: NumberParser
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/BaseValues.h>
#include <NDEVR/Angle.h>
#include <cmath>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief Data for quick text to number lookup
    **/
    constexpr const fltp08 fast_atof_table[20] = {
        0.0,
        0.1,
        0.01,
        0.001,
        0.0001,
        0.00001,
        0.000001,
        0.0000001,
        0.00000001,
        0.000000001,
        0.0000000001,
        0.00000000001,
        0.000000000001,
        0.0000000000001,
        0.00000000000001,
        0.000000000000001,
        0.0000000000000001,
        0.00000000000000001,
        0.000000000000000001,
        0.0000000000000000001,
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief For a given number type, returns the maximum number of digits the number type can represent
    **/
    template<class t_type>
    constexpr uint04 MaxDigits();
 
    template<> constexpr uint04 MaxDigits<uint01>() { return 3; }
    template<> constexpr uint04 MaxDigits<sint01>() { return 3; }
 
    template<> constexpr uint04 MaxDigits<uint02>() { return 5; }
    template<> constexpr uint04 MaxDigits<sint02>() { return 5; }
 
    template<> constexpr uint04 MaxDigits<uint04>() { return 10; }
    template<> constexpr uint04 MaxDigits<sint04>() { return 10; }
 
    template<> constexpr uint04 MaxDigits<sint08>() { return 19; }
    template<> constexpr uint04 MaxDigits<uint08>() { return 20; }
    
    class NumberParser
    {
    public:
        template<class t_type>
        static t_type parse(const char* in, const char** out = nullptr, t_type Invalid_Value = Constant<t_type>::Invalid, bool check_overflow = true)
        {
            return _parse<t_type>(in, out, Invalid_Value, check_overflow);
        }
        template<class t_type>
        static constexpr t_type parseUInt(const char* in, const char** out, t_type Invalid_Value, bool check_overflow)
        {
            if (*in < '0' || *in > '9')
            {
                if (out) *out = in;
                return Invalid_Value;
            }
            t_type value = 0;
            for (uint04 i = 0; i < MaxDigits<t_type>() - 1; i++)
            {
                if (*in < '0' || *in > '9')
                {
                    check_overflow = false;
                    break;
                }
                value = (value * 10) + cast<t_type>(*in - '0');
                ++in;
            }
            if (check_overflow)
            {
                if (*in >= '0' && *in <= '9')//read in last digit
                {
                    t_type new_value = (value * 10) + (*in - '0');
                    ++in;
                    if (new_value < value)
                    {
                        value = Invalid_Value;
                    }
                    else
                    {
                        value = new_value;
                        if (*in > '0' && *in < '9')
                            value = Invalid_Value;
                    }
                }
            }
            if (out)
                *out = in;
            return value;
        }
        // Number of relevant decimals for floating-point parsing.
        template <class t_int_type, typename t_type>
        static t_type parseFloat(const char* c, const char** out_s, t_type Invalid_Value, bool check_overflow)
        {
            if (c == nullptr)
            {
                if (out_s)
                    *out_s = c;
                return Invalid_Value;
            }
            bool inv = (*c == '-');
            if (inv || *c == '+')
                ++c;
            t_int_type value = 0;
            if(*c != '.')
                value = parse<t_int_type>(c, &c, Constant<t_int_type>::Invalid, check_overflow);
            if (IsInvalid(value))
            {
                if (out_s)
                    *out_s = c;
                return Invalid_Value;
            }
            t_type float_value = cast<t_type>(value);
            if (*c == '.')
            {
                ++c;
                const char* c_old = c;
                value = parseUInt<t_int_type>(c, &c, Constant<t_int_type>::Invalid, false);
                if (!IsInvalid(value))
                {
                    fltp08 pl = cast<fltp08>(value);
                    uint04 size = cast<uint04>(c - c_old);
                    pl *= fast_atof_table[size];
                    float_value += cast<t_type>(pl);
                    while (*c >= '0' && *c <= '9')//read in leftover
                        c++;
                }
            }
            if (*c == 'e' || *c == 'E')
            {
                ++c;
                float_value *= cast<t_type>(std::pow(cast<t_type>(10.0), parse<sint02>(c, &c, Constant<sint02>::Invalid, check_overflow)));
            }
            if(out_s)
                *out_s = c;
            if (inv)
                float_value = -float_value;
            return float_value;
        }
 
        // ------------------------------------------------------------------------------------
        // Convert a string in hex format to a number
        // ------------------------------------------------------------------------------------
        static inline uint04 parseHex(const char* in, const char** out = nullptr)
        {
            uint04 value = 0;
            for (;;)
            {
                if (*in >= '0' && *in <= '9')
                    value = (value << 4u) + (*in - '0');
                else if (*in >= 'A' && *in <= 'F')
                    value = (value << 4u) + (*in - 'A') + 10;
                else if (*in >= 'a' && *in <= 'f')
                    value = (value << 4u) + (*in - 'a') + 10;
                else
                    break;
                ++in;
            }
            if (out)*out = in;
            return value;
        }
 
        // ------------------------------------------------------------------------------------
        // Convert just one hex digit
        // Return value is null if the input character is not a hex digit.
        // ------------------------------------------------------------------------------------
        template<class t_char_type>
        static inline uint04 HexDigitToDecimal(t_char_type in)
        {
            uint04 out = Constant<uint04>::Invalid;
            if (in >= '0' && in <= '9')
                out = in - '0';
            else if (in >= 'a' && in <= 'f')
                out = 10u + in - 'a';
            else if (in >= 'A' && in <= 'F')
                out = 10u + in - 'A';
            return out;
        }
 
        // ------------------------------------------------------------------------------------
        // Convert a hex-encoded octet (2 characters, i.e. df or 1a).
        // ------------------------------------------------------------------------------------
        template<class t_char_type>
        static inline uint01 HexOctetToDecimal(const t_char_type* in)
        {
            return (cast<uint01>(HexDigitToDecimal(in[0])) << 4) + cast<uint01>(HexDigitToDecimal(in[1]));
        }
 
        
    private:
        template<class t_type>
        static t_type _parse(const char* in, const char** out, t_type Invalid_Value, bool check_overflow);
        
        template<>
        static inline uint01 _parse(const char* in, const char** out, uint01 Invalid_Value, bool check_overflow)
        {
            if (*in == '+') in++;
            return parseUInt(in, out, Invalid_Value, check_overflow);
        }
        template<>
        static inline uint02 _parse(const char* in, const char** out, uint02 Invalid_Value, bool check_overflow)
        {
            if (*in == '+') in++;
            return parseUInt(in, out, Invalid_Value, check_overflow);
        }
        template<>
        static inline uint04 _parse(const char* in, const char** out, uint04 Invalid_Value, bool check_overflow)
        {
            if (*in == '+') in++;
            return parseUInt(in, out, Invalid_Value, check_overflow);
        }
        template<>
        static inline uint08 _parse(const char* in, const char** out, uint08 Invalid_Value, bool check_overflow)
        {
            if (*in == '+') in++;
            return parseUInt(in, out, Invalid_Value, check_overflow);
        }
        template<>
        static inline sint01 _parse(const char* in, const char** out, sint01 Invalid_Value, bool check_overflow)
        {
            bool inv = (*in == '-');
            if (inv || *in == '+')
                ++in;
            sint01 value = parseUInt<sint01>(in, out, Constant<sint01>::Invalid, check_overflow);
            if (IsInvalid(value))
                return Invalid_Value;
            return inv ? -value : value;
        }
        template<>
        static inline sint02 _parse(const char* in, const char** out, sint02 Invalid_Value, bool check_overflow)
        {
            bool inv = (*in == '-');
            if (inv || *in == '+')
                ++in;
            sint02 value = parseUInt<sint02>(in, out, Constant<sint02>::Invalid, check_overflow);
            if (IsInvalid(value))
                return Invalid_Value;
            return inv ? -value : value;
        }
 
        template<>
        static inline sint04 _parse(const char* in, const char** out, sint04 Invalid_Value, bool check_overflow)
        {
            bool inv = (*in == '-');
            if (inv || *in == '+')
                ++in;
            sint04 value = parseUInt<sint04>(in, out, Constant<sint04>::Invalid, check_overflow);
            if (IsInvalid(value))
                return Invalid_Value;
            return inv ? -value : value;
        }
 
        template<>
        static inline sint08 _parse(const char* in, const char** out, sint08 Invalid_Value, bool check_overflow)
        {
            bool inv = (*in == '-');
            if (inv || *in == '+')
                ++in;
            sint08 value = parseUInt<sint08>(in, out, Constant<sint08>::Invalid, check_overflow);
            if (IsInvalid(value))
                return Invalid_Value;
            if (inv)
                value = -value;
            return value;
        }
        
        // ------------------------------------------------------------------------------------
        // The same but more human.
        template<>
        static inline fltp04 _parse(const char* in, const char** out, fltp04 Invalid_Value, bool check_overflow)
        {
            return parseFloat<uint04, fltp04>(in, out, Invalid_Value, check_overflow);
        }
 
        template<>
        static inline fltp08 _parse(const char* in, const char** out, fltp08 Invalid_Value, bool check_overflow)
        {
            return parseFloat<uint08, fltp08>(in, out, Invalid_Value, check_overflow);
        }
        // ------------------------------------------------------------------------------------
        // Convert a string in octal format to a number
        // ------------------------------------------------------------------------------------
        static inline uint04 parseOctal(const char* in, const char** out = nullptr)
        {
            uint04 value = 0;
            for (;;)
            {
                if (*in < '0' || *in > '7')
                    break;
                value = (value << 3) + (*in - '0');
                ++in;
            }
            if (out)*out = in;
            return value;
        }
 
        
 
        // ------------------------------------------------------------------------------------
        // Parse a C++-like integer literal - hex and oct prefixes.
        // 0xNNNN - hex
        // 0NNN   - oct
        // NNN    - dec
        // ------------------------------------------------------------------------------------
        template<class t_char_type>
        static uint04 strtoul_cppstyle(const t_char_type* in, const t_char_type** out = nullptr)
        {
            if ('0' == in[0])
            {
                return 'x' == in[1] ? strtoul16(in + 2, out) : strtoul8(in + 1, out);
            }
            return strtoul10(in, out);
        }
        template<>
        static inline Angle<sint04> _parse(const char* in, const char** out, Angle<sint04> Invalid_Value, bool check_overflow)
        {
            return Angle<sint04>(NumberParser::_parse<sint04>(in, out, Invalid_Value.internal<false>(), check_overflow));
        }
        template<>
        static inline Angle<fltp08> _parse(const char* in, const char** out, Angle<fltp08> Invalid_Value, bool check_overflow)
        {
            return Angle<fltp08>(NumberParser::_parse<fltp08>(in, out, Invalid_Value.internal<false>(), check_overflow));
        }
        template<>
        static inline Angle<fltp04> _parse(const char* in, const char** out, Angle<fltp04> Invalid_Value, bool check_overflow)
        {
            return Angle<fltp04>(NumberParser::_parse<fltp04>(in, out, Invalid_Value.internal<false>(), check_overflow));
        }
    };
};//End namespace NDEVR