daw_json_parse_iso8601_utils.h

Go to the documentation of this file.

// Copyright (c) Darrell Wright
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/beached/daw_json_link
//
 
#pragma once
 
#include "daw/json/impl/version.h"
 
#include "daw/json/daw_json_switches.h"
#include "daw/json/impl/daw_json_assert.h"
#include "daw/json/impl/daw_json_parse_digit.h"
 
#include <daw/daw_arith_traits.h>
#include <daw/daw_attributes.h>
#include <daw/daw_cpp_feature_check.h>
#include <daw/daw_cxmath.h>
#include <daw/daw_not_null.h>
#include <daw/daw_string_view.h>
#include <daw/daw_traits.h>
#include <daw/daw_uint_buffer.h>
 
#include <cassert>
#include <chrono>
#include <cstdint>
#include <type_traits>
 
namespace daw::json {
  inline namespace DAW_JSON_VER {
    namespace parse_utils {
      template<typename Result, std::size_t count>
      constexpr Result parse_unsigned( daw::not_null<char const *> digit_str ) {
        auto result = UInt64( );
        for( std::size_t n = 0; n < count; ++n ) {
          auto const dig =
            to_uint64( json_details::parse_digit( digit_str[n] ) );
          if( dig >= 10 ) {
            break;
          }
          result *= 10U;
          result += dig;
        }
        return static_cast<Result>( result );
      }
 
      template<typename Result>
      constexpr Result
      parse_unsigned2( daw::not_null<char const *> digit_str ) {
        auto result = UInt64( );
        unsigned dig = json_details::parse_digit( *digit_str );
        while( dig < 10 ) {
          result *= 10U;
          result += dig;
          ++digit_str;
          dig = json_details::parse_digit( *digit_str );
        }
        return static_cast<Result>( result );
      }
 
      DAW_ATTRIB_FLATINLINE constexpr bool is_number( char c ) {
        return json_details::parse_digit( c ) < 10U;
      }
    } // namespace parse_utils
 
    namespace datetime {
      using attoseconds = std::chrono::duration<std::int64_t, std::atto>;
 
      namespace datetime_details {
        template<typename Result>
        constexpr Result parse_number( daw::string_view sv ) {
          static_assert( daw::digits10<Result> >= 4 );
          daw_json_ensure( not sv.empty( ), ErrorReason::InvalidNumber );
          Result result = 0;
          Result sign = 1;
          if( sv.front( ) == '-' ) {
            if constexpr( daw::is_signed_v<Result> ) {
              sign = -1;
            }
            sv.remove_prefix( );
          } else if( sv.front( ) == '+' ) {
            sv.remove_prefix( );
          }
          while( not sv.empty( ) ) {
            auto const dig = json_details::parse_digit( sv.pop_front( ) );
            daw_json_ensure( dig < 10U, ErrorReason::InvalidNumber );
            result *= 10;
            result += static_cast<Result>( dig );
          }
          return result * sign;
        }
      } // namespace datetime_details
      // See:
      // https://stackoverflow.com/questions/16773285/how-to-convert-stdchronotime-point-to-stdtm-without-using-time-t
      template<typename TP = std::chrono::time_point<std::chrono::system_clock,
                                                     std::chrono::milliseconds>>
      constexpr TP civil_to_time_point( std::int32_t yr, std::uint32_t mo,
                                        std::uint32_t dy, std::uint32_t hr,
                                        std::uint32_t mn, std::uint32_t se,
                                        std::uint64_t attosecond ) {
        using Clock = typename TP::clock;
        using Duration = typename TP::duration;
        DAW_CPP23_STATIC_LOCAL constexpr auto calc =
          []( std::int32_t y,
              std::uint32_t m,
              std::uint32_t d,
              std::uint32_t h,
              std::uint32_t min,
              std::uint32_t s,
              std::uint64_t atto ) DAW_JSON_CPP23_STATIC_CALL_OP {
            y -= static_cast<std::int32_t>( m ) <= 2;
            std::int32_t const era = ( y >= 0 ? y : y - 399 ) / 400;
            auto const yoe = static_cast<std::uint32_t>(
              static_cast<std::int32_t>( y ) - era * 400 ); // [0, 399]
            auto const doy = static_cast<std::uint32_t>(
              ( 153 * ( static_cast<std::int32_t>( m ) +
                        ( static_cast<std::int32_t>( m ) > 2 ? -3 : 9 ) ) +
                2 ) /
                5 +
              static_cast<std::int32_t>( d ) - 1 ); // [0, 365]
            std::uint32_t const doe =
              yoe * 365 + yoe / 4 - yoe / 100 + doy; // [0, 146096]
            auto const days_since_epoch =
              static_cast<int64_t>( era ) * 146097LL +
              static_cast<std::int64_t>( doe ) - 719468LL;
 
            auto const dur = std::chrono::floor<Duration>(
              attoseconds( static_cast<std::int64_t>( atto ) ) );
            auto const whole_seconds =
              std::chrono::seconds( days_since_epoch * 86400LL +
                                    static_cast<std::int64_t>( h ) * 3600LL +
                                    static_cast<std::int64_t>( min ) * 60LL +
                                    static_cast<std::int64_t>( s ) );
            return std::chrono::time_point<std::chrono::system_clock,
                                           Duration>{ } +
                   ( std::chrono::duration_cast<Duration>( whole_seconds ) +
                     dur );
          };
        // Not all clocks have the same epoch.  This should account for the
        // offset and adjust the time_point so that the days prior are in
        // relation to unix epoch.  If system_clock is used, as is the default
        // for the return value, it will be zero and should be removed by the
        // compiler
        auto result = calc( yr, mo, dy, hr, mn, se, attosecond );
 
        if constexpr( std::is_same_v<Clock, std::chrono::system_clock> ) {
          return result;
        } else {
#if defined( __cpp_lib_chrono ) and __cpp_lib_chrono >= 201907
          // We have clock_cast
          auto const match_duration =
            std::chrono::time_point_cast<Duration>( result );
          auto const match_clock =
            std::chrono::clock_cast<Clock>( match_duration );
          return match_clock;
#else
          // This is a guess and will not be constexpr
 
          // System epoch is unix epoch on(gcc/clang/msvc)
          auto const system_epoch = std::chrono::floor<std::chrono::hours>(
            std::chrono::system_clock::now( ).time_since_epoch( ) +
            std::chrono::minutes( 30 ) );
          auto const clock_epoch = std::chrono::floor<std::chrono::hours>(
            Clock::now( ).time_since_epoch( ) + std::chrono::minutes( 30 ) );
 
          DAW_CPP23_STATIC_LOCAL constexpr auto offset =
            std::chrono::duration_cast<std::chrono::milliseconds>(
              clock_epoch - system_epoch );
          return std::chrono::duration_cast<Duration>( result + offset );
#endif
        }
      }
 
      struct date_parts {
        std::int32_t year;
        std::uint32_t month;
        std::uint32_t day;
      };
 
      constexpr date_parts
      parse_iso_8601_date( daw::string_view timestamp_str ) {
        auto result = date_parts{ 0, 0, 0 };
        result.day = parse_utils::parse_unsigned<std::uint_least32_t, 2>(
          std::data( timestamp_str.pop_back( 2U ) ) );
        daw_json_ensure( result.day >= 1 and result.day <= 31,
                         ErrorReason::InvalidTimestamp );
        if( not parse_utils::is_number( timestamp_str.back( ) ) ) {
          timestamp_str.remove_suffix( );
        }
        result.month = parse_utils::parse_unsigned<std::uint_least32_t, 2>(
          std::data( timestamp_str.pop_back( 2U ) ) );
        daw_json_ensure( result.month >= 1 and result.month <= 12,
                         ErrorReason::InvalidTimestamp );
        if( not parse_utils::is_number( timestamp_str.back( ) ) ) {
          timestamp_str.remove_suffix( );
        }
        result.year =
          datetime_details::parse_number<std::int_least32_t>( timestamp_str );
        auto max_day = std::uint32_t{ 31 };
        if( result.month == 2 ) {
          auto const is_leap_year =
            result.year % 4 == 0 and
            ( result.year % 100 != 0 or result.year % 400 == 0 );
          max_day = is_leap_year ? 29U : 28U;
        } else if( result.month == 4 or result.month == 6 or
                   result.month == 9 or result.month == 11 ) {
          max_day = 30;
        }
        daw_json_ensure( result.day <= max_day,
                         ErrorReason::InvalidTimestamp );
        return result;
      }
 
      struct time_parts {
        std::uint_least32_t hour;
        std::uint_least32_t minute;
        std::uint_least32_t second;
        std::uint64_t attosecond;
      };
 
      constexpr time_parts
      parse_iso_8601_time( daw::string_view timestamp_str ) {
        auto result = time_parts{ 0, 0, 0, 0 };
        result.hour = parse_utils::parse_unsigned<std::uint_least32_t, 2>(
          std::data( timestamp_str.pop_front( 2 ) ) );
        daw_json_ensure( result.hour <= 24, ErrorReason::InvalidTimestamp );
        if( not parse_utils::is_number( timestamp_str.front( ) ) ) {
          timestamp_str.remove_prefix( );
        }
        result.minute = parse_utils::parse_unsigned<std::uint_least32_t, 2>(
          std::data( timestamp_str.pop_front( 2 ) ) );
        daw_json_ensure( result.minute <= 59, ErrorReason::InvalidTimestamp );
        if( timestamp_str.empty( ) ) {
          daw_json_ensure( result.hour != 24 or result.minute == 0,
                           ErrorReason::InvalidTimestamp );
          return result;
        }
        if( not parse_utils::is_number( timestamp_str.front( ) ) ) {
          timestamp_str.remove_prefix( );
        }
        result.second = parse_utils::parse_unsigned<std::uint_least32_t, 2>(
          std::data( timestamp_str.pop_front( 2 ) ) );
        daw_json_ensure( result.second <= 60, ErrorReason::InvalidTimestamp );
        if( timestamp_str.empty( ) ) {
          daw_json_ensure( result.hour != 24 or
                             ( result.minute == 0 and result.second == 0 ),
                           ErrorReason::InvalidTimestamp );
          return result;
        }
        daw_json_ensure( timestamp_str.front( ) == '.',
                         ErrorReason::InvalidTimestamp );
        timestamp_str.remove_prefix( );
        daw_json_ensure( not timestamp_str.empty( ),
                         ErrorReason::InvalidTimestamp );
        for( char const c : timestamp_str ) {
          daw_json_ensure( parse_utils::is_number( c ),
                           ErrorReason::InvalidTimestamp );
        }
        auto const precision =
          (std::min)( { timestamp_str.size( ), std::size_t{ 18 } } );
        auto const attosecond_str = timestamp_str.substr( 0, precision );
        result.attosecond =
          datetime_details::parse_number<std::uint64_t>( attosecond_str );
        result.attosecond *= daw::cxmath::pow10( 18 - precision );
        daw_json_ensure(
          result.hour != 24 or
            ( result.minute == 0 and result.second == 0 and
              result.attosecond == 0 ),
          ErrorReason::InvalidTimestamp );
        return result;
      }
 
      template<typename TP>
      constexpr TP parse_iso8601_timestamp( daw::string_view ts ) {
        DAW_CPP23_STATIC_LOCAL constexpr daw::string_view t_str = "T";
        auto const date_str = ts.pop_front_until( t_str );
        if( ts.empty( ) ) {
          daw_json_error( true,
                          ErrorReason::InvalidTimestamp ); // Invalid timestamp,
          // missing T separator
        }
 
        date_parts const ymd = parse_iso_8601_date( date_str );
        auto time_str = ts.pop_front_until(
          []( char c ) DAW_JSON_CPP23_STATIC_CALL_OP {
            return not( parse_utils::is_number( c ) | ( c == ':' ) |
                        ( c == '.' ) );
          },
          nodiscard );
        // TODO: verify or parse timezone
        auto const hms = parse_iso_8601_time( time_str );
 
        auto const local_tp = civil_to_time_point<TP>( ymd.year,
                                                       ymd.month,
                                                       ymd.day,
                                                       hms.hour,
                                                       hms.minute,
                                                       hms.second,
                                                       hms.attosecond );
        if( ts.empty( ) or ts.front( ) == 'Z' ) {
          return local_tp;
        }
        daw_json_ensure( std::size( ts ) == 5 or std::size( ts ) == 6,
                         ErrorReason::InvalidTimestamp );
        // The format will be (+|-)hh[:]mm
        bool sign = false;
        switch( ts.front( ) ) {
        case '+':
          sign = true;
          break;
        case '-':
          break;
        default:
          daw_json_error( true, ErrorReason::InvalidTimestamp );
        }
        ts.remove_prefix( );
        auto hr_offset_str = ts.pop_front( 2 );
        auto mn_offset_str = daw::string_view{ };
        if( hr_offset_str.size( ) == 4 ) {
          mn_offset_str = hr_offset_str.pop_back( 2 );
        }
        daw_json_ensure( hr_offset_str.size( ) == 2 and
                           parse_utils::is_number( hr_offset_str[0] ) and
                           parse_utils::is_number( hr_offset_str[1] ),
                         ErrorReason::InvalidTimestamp );
 
        auto const hr_offset =
          parse_utils::parse_unsigned<std::uint_least32_t, 2>(
            std::data( hr_offset_str ) );
        daw_json_ensure( hr_offset <= 24, ErrorReason::InvalidTimestamp );
        if( not ts.empty( ) and ts.front( ) == ':' ) {
          ts.remove_prefix( );
        }
        if( mn_offset_str.empty( ) ) {
          mn_offset_str = ts.pop_front( 2 );
        }
        daw_json_ensure( mn_offset_str.size( ) == 2 and ts.empty( ) and
                           parse_utils::is_number( mn_offset_str[0] ) and
                           parse_utils::is_number( mn_offset_str[1] ),
                         ErrorReason::InvalidTimestamp );
        auto const mn_offset =
          parse_utils::parse_unsigned<std::uint_least32_t, 2>(
            std::data( mn_offset_str ) );
        daw_json_ensure( mn_offset <= 61, ErrorReason::InvalidTimestamp );
 
        if( hr_offset == 0 and mn_offset == 0 ) {
          return std::chrono::time_point_cast<typename TP::duration>(
            local_tp );
        }
        // Apply the offset as a duration on the time_point so that
        // borrowing across hour/day boundaries (e.g. 01:14 - 02:30)
        // is handled by chrono instead of wrapping unsigned fields.
        auto const offset = std::chrono::seconds{
          static_cast<std::chrono::seconds::rep>( hr_offset ) * 3600 +
          static_cast<std::chrono::seconds::rep>( mn_offset ) * 60 };
        // Want to subtract offset from current time, we are converting to UTC
        if( sign ) {
          // Positive offset
          return std::chrono::time_point_cast<typename TP::duration>(
                   local_tp ) -
                 std::chrono::duration_cast<typename TP::duration>( offset );
        }
        // Negative offset
        return std::chrono::time_point_cast<typename TP::duration>( local_tp ) +
               std::chrono::duration_cast<typename TP::duration>( offset );
      }
      struct ymdhms {
        std::int_least32_t year;
        std::uint_least32_t month;
        std::uint_least32_t day;
        std::uint_least32_t hour;
        std::uint_least32_t minute;
        std::uint_least32_t second;
        std::uint64_t attosecond;
      };
 
      template<typename Clock, typename Duration>
      constexpr ymdhms
      time_point_to_civil( std::chrono::time_point<Clock, Duration> const tp ) {
        auto dur_from_epoch = tp.time_since_epoch( );
        using Days =
          std::chrono::duration<std::int_least32_t, std::ratio<86400>>;
        auto const whole_seconds =
          std::chrono::floor<std::chrono::seconds>( dur_from_epoch );
        auto const days_since_epoch = std::chrono::floor<Days>( whole_seconds );
        std::int_least32_t z = days_since_epoch.count( );
        z += 719468;
        std::int_least32_t const era = ( z >= 0 ? z : z - 146096 ) / 146097;
        auto const doe =
          static_cast<std::uint_least32_t>( z - era * 146097 ); // [0, 146096]
        std::uint_least32_t const yoe =
          ( doe - doe / 1460 + doe / 36524 - doe / 146096 ) / 365; // [0, 399]
        std::int_least32_t const y =
          static_cast<std::int_least32_t>( yoe ) + era * 400;
        std::uint_least32_t const doy =
          doe - ( 365 * yoe + yoe / 4 - yoe / 100 );          // [0, 365]
        std::uint_least32_t const mp = ( 5 * doy + 2 ) / 153; // [0, 11]
        std::uint_least32_t const d = doy - ( 153 * mp + 2 ) / 5 + 1; // [1, 31]
        auto const m = static_cast<std::uint_least32_t>(
          static_cast<std::int_least32_t>( mp ) +
          ( static_cast<std::int_least32_t>( mp ) < 10 ? 3 : -9 ) ); // [1, 12]
 
        auto dur_in_day =
          whole_seconds -
          std::chrono::duration_cast<std::chrono::seconds>( days_since_epoch );
        auto const hrs =
          std::chrono::duration_cast<std::chrono::hours>( dur_in_day );
        dur_in_day -= hrs;
        auto const min =
          std::chrono::duration_cast<std::chrono::minutes>( dur_in_day );
        dur_in_day -= min;
        auto const sec =
          std::chrono::duration_cast<std::chrono::seconds>( dur_in_day );
        auto const subseconds =
          dur_from_epoch -
          std::chrono::duration_cast<Duration>( whole_seconds );
        auto const dur = std::chrono::duration_cast<attoseconds>( subseconds );
        return ymdhms{ y + ( m <= 2 ),
                       m,
                       d,
                       static_cast<std::uint_least32_t>( hrs.count( ) ),
                       static_cast<std::uint_least32_t>( min.count( ) ),
                       static_cast<std::uint_least32_t>( sec.count( ) ),
                       static_cast<std::uint64_t>( dur.count( ) ) };
      }
 
      constexpr std::string_view month_short_name( unsigned m ) {
        switch( m ) {
        case 1:
          return { "Jan" };
        case 2:
          return { "Feb" };
        case 3:
          return { "Mar" };
        case 4:
          return { "Apr" };
        case 5:
          return { "May" };
        case 6:
          return { "Jun" };
        case 7:
          return { "Jul" };
        case 8:
          return { "Aug" };
        case 9:
          return { "Sep" };
        case 10:
          return { "Oct" };
        case 11:
          return { "Nov" };
        case 12:
          return { "Dec" };
        default:
          DAW_UNLIKELY_BRANCH
          daw_json_error( true,
                          ErrorReason::InvalidTimestamp ); // Invalid month
        }
      }
 
      // Formula from
      // http://howardhinnant.github.io/date_algorithms.html#weekday_from_days
      template<typename Duration>
      constexpr std::string_view short_day_of_week(
        std::chrono::time_point<std::chrono::system_clock, Duration> tp ) {
        using days = std::chrono::duration<long, std::ratio<86400>>;
        auto const z =
          std::chrono::duration_cast<days>( tp.time_since_epoch( ) ).count( );
        auto const dow = z >= -4L ? ( z + 4L ) % 7L : ( z + 5L ) % 7L + 6L;
        switch( dow ) {
        case 0:
          return { "Sun" };
        case 1:
          return { "Mon" };
        case 2:
          return { "Tue" };
        case 3:
          return { "Wed" };
        case 4:
          return { "Thu" };
        case 5:
          return { "Fri" };
        case 6:
          return { "Sat" };
        default:
          DAW_UNLIKELY_BRANCH
          daw_json_error( true,
                          ErrorReason::InvalidTimestamp ); // Invalid month
        }
      }
 
      namespace datetime_details {
        constexpr std::uint_least32_t month2num( std::string_view ts ) {
          daw_json_ensure( std::size( ts ) >= 3,
                           ErrorReason::InvalidTimestamp );
          auto const b0 = static_cast<std::uint_least32_t>(
            static_cast<unsigned char>( ts[0] ) );
          auto const b1 = static_cast<std::uint_least32_t>(
            static_cast<unsigned char>( ts[1] ) );
          auto const b2 = static_cast<std::uint_least32_t>(
            static_cast<unsigned char>( ts[2] ) );
          return ( b0 << 16U ) | ( b1 << 8U ) | b2;
        }
      } // namespace datetime_details
 
      constexpr unsigned parse_short_month( std::string_view ts ) {
        // Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec
        switch( datetime_details::month2num( ts ) ) {
        case datetime_details::month2num( "Jan" ):
          return 1;
        case datetime_details::month2num( "Feb" ):
          return 2;
        case datetime_details::month2num( "Mar" ):
          return 3;
        case datetime_details::month2num( "Apr" ):
          return 4;
        case datetime_details::month2num( "May" ):
          return 5;
        case datetime_details::month2num( "Jun" ):
          return 6;
        case datetime_details::month2num( "Jul" ):
          return 7;
        case datetime_details::month2num( "Aug" ):
          return 8;
        case datetime_details::month2num( "Sep" ):
          return 9;
        case datetime_details::month2num( "Oct" ):
          return 10;
        case datetime_details::month2num( "Nov" ):
          return 11;
        case datetime_details::month2num( "Dec" ):
          return 12;
        default:
          DAW_UNLIKELY_BRANCH
          daw_json_error( true,
                          ErrorReason::InvalidTimestamp ); // Invalid month
        }
      }
    } // namespace datetime
  } // namespace DAW_JSON_VER
} // namespace daw::json