Fix constexpr overflow problems on gcc-7-9

* Ubuntu needs to use readlink under current_zone
  and most everyone else needs realpath.  Attempting
  to make everyone happy with this commit.

.gitignore

@@ -0,0 +1,194 @@
+#ignore thumbnails created by windows
+Thumbs.db
+#Ignore files build by Visual Studio
+*.obj
+*.exe
+*.pdb
+*.user
+*.aps
+*.pch
+*.vspscc
+*_i.c
+*_p.c
+*.ncb
+*.suo
+*.tlb
+*.tlh
+*.bak
+*.cache
+*.ilk
+*.log
+[Bb]in
+[Dd]ebug*/
+*.lib
+*.sbr
+obj/
+[Rr]elease*/
+_ReSharper*/
+[Tt]est[Rr]esult*
+.idea/
+*.opensdf
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+# User-specific folders
+*.sln.ide/
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+build/
+bld/
+[Bb]in/
+[Oo]bj/
+# Roslyn cache directories
+*.ide/
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+#NUNIT
+*.VisualState.xml
+TestResult.xml
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+# Chutzpah Test files
+_Chutzpah*
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opensdf
+*.sdf
+*.cachefile
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+# TFS 2012 Local Workspace
+$tf/
+# Guidance Automation Toolkit
+*.gpState
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+# JustCode is a .NET coding addin-in
+.JustCode
+# TeamCity is a build add-in
+_TeamCity*
+# DotCover is a Code Coverage Tool
+*.dotCover
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+# Web workbench (sass)
+.sass-cache/
+# Installshield output folder
+[Ee]xpress/
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+# Click-Once directory
+publish/
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# TODO: Comment the next line if you want to checkin your web deploy settings 
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# If using the old MSBuild-Integrated Package Restore, uncomment this:
+#!**/packages/repositories.config
+# Windows Azure Build Output
+csx/
+*.build.csdef
+# Windows Store app package directory
+AppPackages/
+# Others
+sql/
+*.Cache
+ClientBin/
+[Ss]tyle[Cc]op.*
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.pfx
+*.publishsettings
+node_modules/
+bower_components/
+# RIA/Silverlight projects
+Generated_Code/
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+# SQL Server files
+*.mdf
+*.ldf
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+# Microsoft Fakes
+FakesAssemblies/
+*.suo
+*.vcxproj.filters
+*.npp
+CMakeFiles/*
+nbproject/*
+*.cd
+*.cd
+a.out
+cmake-build-debug/*

.travis.yml

@@ -0,0 +1,147 @@
+language: cpp
+
+env:
+  global:
+    - CMAKE_EXTRA_CONF="-DCOMPILE_WITH_C_LOCALE=ON"
+    - CTEST_OUTPUT_ON_FAILURE=1
+
+matrix:
+  include:
+
+    - name: "Ubuntu 16.04 LTS (Xenial Xerus) GCC 7"
+      os: linux
+      dist: xenial
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-7
+      env:
+        - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
+
+    - name: "Ubuntu 16.04 LTS (Xenial Xerus) GCC 8"
+      os: linux
+      dist: xenial
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-8
+      env:
+        - MATRIX_EVAL="CC=gcc-8 && CXX=g++-8"
+
+    - name: "Ubuntu 16.04 LTS (Xenial Xerus) GCC 9"
+      os: linux
+      dist: xenial
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-9
+      env:
+        - MATRIX_EVAL="CC=gcc-9 && CXX=g++-9"
+
+    - name: "Ubuntu 18.04 LTS (Bionic Beaver) GCC 7"
+      os: linux
+      dist: bionic
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-7
+      env:
+        - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
+
+    - name: "Ubuntu 18.04 LTS (Bionic Beaver) GCC 8"
+      os: linux
+      dist: bionic
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-8
+      env:
+        - MATRIX_EVAL="CC=gcc-8 && CXX=g++-8"
+
+    - name: "Ubuntu 18.04 LTS (Bionic Beaver) Clang 6"
+      os: linux
+      dist: bionic
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-6.0
+          packages:
+            - clang-6.0
+      env:
+        - MATRIX_EVAL="CC=clang-6.0 && CXX=clang++-6.0"
+
+    - name: "Ubuntu 18.04 LTS (Bionic Beaver) Clang 7"
+      os: linux
+      dist: bionic
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-7
+          packages:
+            - clang-7
+      env:
+        - MATRIX_EVAL="CC=clang-7 && CXX=clang++-7"
+
+    - name: "Ubuntu 18.04 LTS (Bionic Beaver) Clang 8"
+      os: linux
+      dist: bionic
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-8
+          packages:
+            - clang-8
+      env:
+        - MATRIX_EVAL="CC=clang-8 && CXX=clang++-8"
+
+    - &macos
+      name: xcode10
+      os: osx
+      osx_image: xcode10.2
+      env:
+        - CMAKE_EXTRA_CONF=""
+      addons:
+        homebrew:
+          packages:
+            - bash
+            - ninja
+
+    - <<: *macos
+      name: xcode9
+      # xcode 9 only works if we tell it to use c++14 explicitly
+      env:
+        - CMAKE_EXTRA_CONF="-DCMAKE_CXX_STANDARD=14"
+      osx_image: xcode9.4
+
+    - <<: *macos
+      osx_image: xcode11
+      name: xcode11
+
+before_install:
+  - eval "${MATRIX_EVAL}"
+  - ci/install_cmake.sh 3.15.2
+  - export OPENSSL_ROOT=$(brew --prefix openssl@1.1)
+  - if [ "$(uname)" = "Darwin" ] ; then export PATH="$HOME/cmake/CMake.app/Contents/bin:${PATH}"; fi
+  - if [ "$(uname)" = "Linux" ] ; then export PATH="$HOME/cmake/bin:${PATH}"; fi
+
+cache:
+  directories:
+    - $HOME/cmake
+
+script:
+  - mkdir -p build
+  - cd build
+  - eval cmake -DENABLE_DATE_TESTING=ON -DBUILD_SHARED_LIBS=ON ${CMAKE_EXTRA_CONF} ..
+  - cmake --build . --parallel
+  - cmake --build . --parallel --target testit
+

CMakeLists.txt

@@ -0,0 +1,248 @@
+#[===================================================================[
+   date library by Howard Hinnant
+
+   CMake projects that wish to use this library should consider
+   something like the following :
+
+     include( FetchContent )
+     FetchContent_Declare( date_src
+       GIT_REPOSITORY https://github.com/HowardHinnant/date.git
+       GIT_TAG        2.4.2  # adjust tag/branch/commit as needed
+     )
+     FetchContent_MakeAvailable(date_src)
+     ...
+     target_link_libraries (my_target PRIVATE date::date)
+
+#]===================================================================]
+
+cmake_minimum_required( VERSION 3.7 )
+
+project( date VERSION 2.4.1 )
+
+include( GNUInstallDirs )
+
+get_directory_property( has_parent PARENT_DIRECTORY )
+
+# Override by setting on CMake command line.
+set( CMAKE_CXX_STANDARD 17 CACHE STRING "The C++ standard whose features are requested." )
+
+option( USE_SYSTEM_TZ_DB "Use the operating system's timezone database" OFF )
+option( MANUAL_TZ_DB "User will set TZ DB manually by invoking set_install in their code" OFF )
+option( USE_TZ_DB_IN_DOT "Save the timezone database in the current folder" OFF )
+option( BUILD_SHARED_LIBS  "Build a shared version of library" OFF )
+option( ENABLE_DATE_TESTING "Enable unit tests" OFF )
+option( DISABLE_STRING_VIEW "Disable string view" OFF )
+option( COMPILE_WITH_C_LOCALE "define ONLY_C_LOCALE=1" OFF )
+option( BUILD_TZ_LIB "build/install of TZ library" OFF )
+
+if( ENABLE_DATE_TESTING AND NOT BUILD_TZ_LIB )
+    message(WARNING "Testing requested, bug BUILD_TZ_LIB not ON - forcing the latter")
+    set (BUILD_TZ_LIB ON CACHE BOOL "required for testing" FORCE)
+endif( )
+
+function( print_option OPT )
+    if ( NOT DEFINED PRINT_OPTION_CURR_${OPT} OR ( NOT PRINT_OPTION_CURR_${OPT} STREQUAL ${OPT} ) )
+        set( PRINT_OPTION_CURR_${OPT} ${${OPT}} CACHE BOOL "" )
+        mark_as_advanced(PRINT_OPTION_CURR_${OPT})
+        message( "# date: ${OPT} ${${OPT}}" )
+    endif( )
+endfunction( )
+
+print_option( USE_SYSTEM_TZ_DB )
+print_option( MANUAL_TZ_DB )
+print_option( USE_TZ_DB_IN_DOT )
+print_option( BUILD_SHARED_LIBS  )
+print_option( ENABLE_DATE_TESTING )
+print_option( DISABLE_STRING_VIEW )
+
+#[===================================================================[
+   date (header only) library
+#]===================================================================]
+add_library( date INTERFACE )
+add_library( date::date ALIAS date )
+target_include_directories( date INTERFACE
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include> )
+# adding header sources just helps IDEs
+target_sources( date INTERFACE
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>$<INSTALL_INTERFACE:include>/date/date.h
+    # the rest of these are not currently part of the public interface of the library:
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include/date/solar_hijri.h>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include/date/islamic.h>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include/date/iso_week.h>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include/date/julian.h>
+)
+if (CMAKE_VERSION VERSION_GREATER_EQUAL 3.15)
+    # public headers will get installed:
+    set_target_properties( date PROPERTIES PUBLIC_HEADER include/date/date.h )
+endif ()
+target_compile_definitions( date INTERFACE
+    #To workaround libstdc++ issue https://github.com/HowardHinnant/date/issues/388
+    ONLY_C_LOCALE=$<IF:$<BOOL:${COMPILE_WITH_C_LOCALE}>,1,0>
+    $<$<BOOL:${DISABLE_STRING_VIEW}>:HAS_STRING_VIEW=0> )
+
+#[===================================================================[
+   tz (compiled) library
+#]===================================================================]
+if( BUILD_TZ_LIB )
+    add_library( tz )
+    target_sources( tz
+      PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>$<INSTALL_INTERFACE:include>/date/tz.h
+        $<$<BOOL:${IOS}>:$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>$<INSTALL_INTERFACE:include>/date/ios.h>
+      PRIVATE
+        include/date/tz_private.h
+        $<$<BOOL:${IOS}>:src/ios.mm>
+        src/tz.cpp )
+    add_library( date::tz ALIAS tz )
+    target_link_libraries( tz PUBLIC date )
+    target_include_directories( tz PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include> )
+    target_compile_definitions( tz
+        PRIVATE
+            AUTO_DOWNLOAD=$<IF:$<OR:$<BOOL:${USE_SYSTEM_TZ_DB}>,$<BOOL:${MANUAL_TZ_DB}>>,0,1>
+            HAS_REMOTE_API=$<IF:$<OR:$<BOOL:${USE_SYSTEM_TZ_DB}>,$<BOOL:${MANUAL_TZ_DB}>>,0,1>
+            $<$<AND:$<BOOL:${WIN32}>,$<BOOL:${BUILD_SHARED_LIBS}>>:DATE_BUILD_DLL=1>
+            $<$<BOOL:${USE_TZ_DB_IN_DOT}>:INSTALL=.>
+        PUBLIC
+            USE_OS_TZDB=$<IF:$<AND:$<BOOL:${USE_SYSTEM_TZ_DB}>,$<NOT:$<BOOL:${WIN32}>>,$<NOT:$<BOOL:${MANUAL_TZ_DB}>>>,1,0>
+        INTERFACE
+            $<$<AND:$<BOOL:${WIN32}>,$<BOOL:${BUILD_SHARED_LIBS}>>:DATE_USE_DLL=1> )
+    set(TZ_HEADERS include/date/tz.h)
+    if( IOS )
+        list(APPEND TZ_HEADERS include/date/ios.h)
+    endif( )
+    set_target_properties( tz PROPERTIES
+        POSITION_INDEPENDENT_CODE ON
+        PUBLIC_HEADER "${TZ_HEADERS}"
+        VERSION "${PROJECT_VERSION}"
+        SOVERSION "${PROJECT_VERSION}" )
+    if( NOT MSVC )
+        find_package( Threads )
+        target_link_libraries( tz PUBLIC Threads::Threads )
+    endif( )
+    if( NOT USE_SYSTEM_TZ_DB AND NOT MANUAL_TZ_DB )
+        find_package( CURL REQUIRED )
+        target_include_directories( tz SYSTEM PRIVATE ${CURL_INCLUDE_DIRS} )
+        target_link_libraries( tz PRIVATE ${CURL_LIBRARIES} )
+    endif( )
+endif( )
+
+#[===================================================================[
+   installation
+#]===================================================================]
+set( version_config "${CMAKE_CURRENT_BINARY_DIR}/dateConfigVersion.cmake" )
+
+include( CMakePackageConfigHelpers )
+write_basic_package_version_file( "${version_config}"
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY SameMajorVersion )
+
+install( TARGETS date
+    EXPORT dateConfig
+    PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/date )
+export( TARGETS date NAMESPACE date:: FILE dateTargets.cmake )
+if (CMAKE_VERSION VERSION_LESS 3.15)
+    install(
+        FILES include/date/date.h
+        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/date )
+endif ()
+
+if( BUILD_TZ_LIB )
+    install( TARGETS tz
+        EXPORT dateConfig
+        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/date
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} )  # This is for Windows
+    export( TARGETS tz NAMESPACE date:: APPEND FILE dateTargets.cmake )
+endif( )
+
+if( WIN32 AND NOT CYGWIN)
+    set( CONFIG_LOC CMake )
+else( )
+    set( CONFIG_LOC "${CMAKE_INSTALL_LIBDIR}/cmake/date" )
+endif( )
+install( EXPORT dateConfig
+  FILE dateTargets.cmake
+  NAMESPACE date::
+  DESTINATION ${CONFIG_LOC} )
+install (
+  FILES cmake/dateConfig.cmake "${version_config}"
+  DESTINATION ${CONFIG_LOC})
+
+#[===================================================================[
+   testing
+#]===================================================================]
+if( ENABLE_DATE_TESTING )
+    enable_testing( )
+
+    add_custom_target( testit COMMAND ${CMAKE_CTEST_COMMAND} )
+    add_dependencies( testit tz )
+
+    function( add_pass_tests TEST_GLOB TEST_PREFIX )
+        file( GLOB_RECURSE FILENAMES ${TEST_GLOB} )
+
+        foreach( TEST_FILE ${FILENAMES} )
+            get_filename_component( TEST_NAME ${TEST_FILE} NAME_WE )
+            get_filename_component( TEST_EXT ${TEST_FILE} EXT )
+            if( NOT ${TEST_EXT} STREQUAL ".fail.cpp" )
+                set( PREFIX "${TEST_PREFIX}_pass_${TEST_NAME}" )
+                set( BIN_NAME ${PREFIX}_bin )
+                set( TST_NAME ${PREFIX}_test )
+                add_executable( ${BIN_NAME} EXCLUDE_FROM_ALL ${TEST_FILE} )
+                add_test( ${TST_NAME} ${BIN_NAME} )
+                target_link_libraries( ${BIN_NAME} tz )
+                # HACK: because the test files don't use FQ includes:
+                target_include_directories( ${BIN_NAME} PRIVATE include/date )
+                add_dependencies( testit ${BIN_NAME} )
+            endif( )
+        endforeach( )
+    endfunction( )
+
+    function( add_fail_tests TEST_GLOB TEST_PREFIX )
+        file( GLOB_RECURSE FILENAMES ${TEST_GLOB} )
+
+        foreach( TEST_FILE ${FILENAMES} )
+            get_filename_component( TEST_NAME ${TEST_FILE} NAME_WE )
+            get_filename_component( TEST_EXT ${TEST_FILE} EXT )
+
+            set( TEST_TYPE "_fail" )
+
+            set( PREFIX "${TEST_PREFIX}_fail_${TEST_NAME}" )
+            set( BIN_NAME ${PREFIX}_bin )
+            set( TST_NAME ${PREFIX}_test )
+
+            set( TEST_BIN_NAME ${CMAKE_BINARY_DIR}/${BIN_NAME} )
+            add_custom_target( ${BIN_NAME}
+                COMMAND
+                    ${PROJECT_SOURCE_DIR}/compile_fail.sh
+                    ${TEST_BIN_NAME}
+                    ${CMAKE_CXX_COMPILER}
+                    -std=c++14
+                    -L${CMAKE_BINARY_DIR}/
+                    -ltz
+                    -I${PROJECT_SOURCE_DIR}/include
+                    -I${PROJECT_SOURCE_DIR}/include/date
+                    -o ${BIN_NAME}
+                    ${TEST_FILE}
+                WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+                COMMENT ${TST_NAME} )
+            add_test( ${TST_NAME} "${PROJECT_SOURCE_DIR}/test_fail.sh" ${CMAKE_BINARY_DIR}/${BIN_NAME} WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/" )
+            #set_tests_properties( ${TST_NAME} PROPERTIES WILL_FAIL TRUE)
+            add_dependencies( testit ${BIN_NAME} )
+        endforeach( )
+    endfunction( )
+
+    file( GLOB children RELATIVE "${PROJECT_SOURCE_DIR}/test" "${PROJECT_SOURCE_DIR}/test/*" )
+    foreach( child ${children} )
+        if( IS_DIRECTORY "${PROJECT_SOURCE_DIR}/test/${child}" )
+            set( CUR_FOLDER "${PROJECT_SOURCE_DIR}/test/${child}" )
+            add_pass_tests( "${CUR_FOLDER}/*.cpp" ${child} )
+            if( NOT WIN32 )
+                add_fail_tests( "${CUR_FOLDER}/*.fail.cpp" ${child} )
+            endif( )
+        endif( )
+    endforeach( )
+endif( )

LICENSE.txt

@@ -0,0 +1,31 @@
+The source code in this project is released using the MIT License. There is no
+global license for the project because each file is licensed individually with
+different author names and/or dates.
+
+If you contribute to this project, please add your name to the license of each
+file you modify.  If you have already contributed to this project and forgot to
+add your name to the license, please feel free to submit a new P/R to add your
+name to the license in each file you modified.
+
+For convenience, here is a copy of the MIT license found in each file except
+without author names or dates:
+
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+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.

README.md

@@ -1,11 +1,72 @@
-This is actually three separate C++11/C++14 libraries:
+# Date
 
-1.  `"date.h"` is a header-only library which builds upon `<chrono>`.  It adds some new `duration` types, and new `time_point` types.  It also adds "field" types such as `year_month_day` which is a struct `{year, month, day}`.  And it provides convenient means to convert between the "field" types and the `time_point` types.  See http://howardhinnant.github.io/date_v2.html for more details.
+[![Build Status](https://travis-ci.org/HowardHinnant/date.svg?branch=master)](https://travis-ci.org/HowardHinnant/date)
+[![Join the chat at https://gitter.im/HowardHinnant/date](https://badges.gitter.im/HowardHinnant/date.svg)](https://gitter.im/HowardHinnant/date?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-    Here is the Cppcon 2015 presentation on date.h: https://www.youtube.com/watch?v=tzyGjOm8AKo
+---
 
-    Here are the Cppcon 2015 slides on date.h: http://schd.ws/hosted_files/cppcon2015/43/hinnant_dates.pdf
+**[Try it out on wandbox!](https://wandbox.org/permlink/L8MwjzSSC3fXXrMd)**
 
-2. `"tz.h"` / `"tz.cpp"`  are a timezone library built on top of the `"date.h"` library.  This timezone library is a complete parser of the IANA timezone database.  It provides for an easy way to access all of the data in this database, using the types from `"date.h"` and `<chrono>`.  The IANA database also includes data on leap seconds, and this library provides utilities to compute with that information as well.  See http://howardhinnant.github.io/tz.html for more details.  See the `auto_download` branch for an experimental version of this library which auto-installs the latest version of the IANA timezone database (if you are connected to the internet).
+## Summary
 
-3. `"iso_week.h"` is a header-only library built on top of the `"date.h"` library which implements the ISO week date calendar.  See http://howardhinnant.github.io/iso_week.html for more details.
+This is actually several separate C++11/C++14/C++17 libraries:
+
+1. `"date.h"` is a header-only library which builds upon `<chrono>`.  It adds some new `duration` types, and new `time_point` types.  It also adds "field" types such as `year_month_day` which is a struct `{year, month, day}`.  And it provides convenient means to convert between the "field" types and the `time_point` types.
+
+    * Documentation: http://howardhinnant.github.io/date/date.html
+    * Video: https://www.youtube.com/watch?v=tzyGjOm8AKo
+    * Slides: http://schd.ws/hosted_files/cppcon2015/43/hinnant_dates.pdf
+
+1. `"tz.h"` / `"tz.cpp"`  are a timezone library built on top of the `"date.h"` library.  This timezone library is a complete parser of the IANA timezone database.  It provides for an easy way to access all of the data in this database, using the types from `"date.h"` and `<chrono>`.  The IANA database also includes data on leap seconds, and this library provides utilities to compute with that information as well.
+
+    * Documentation: http://howardhinnant.github.io/date/tz.html
+    * Video: https://www.youtube.com/watch?v=Vwd3pduVGKY
+    * Slides: http://schd.ws/hosted_files/cppcon2016/0f/Welcome%20To%20The%20Time%20Zone%20-%20Howard%20Hinnant%20-%20CppCon%202016.pdf
+
+1. `"iso_week.h"` is a header-only library built on top of the `"date.h"` library which implements the ISO week date calendar.
+
+    * Documentation: http://howardhinnant.github.io/date/iso_week.html
+
+1. `"julian.h"` is a header-only library built on top of the `"date.h"` library which implements a proleptic Julian calendar which is fully interoperable with everything above.
+
+    * Documentation: http://howardhinnant.github.io/date/julian.html
+
+1. `"islamic.h"` is a header-only library built on top of the `"date.h"` library which implements a proleptic Islamic calendar which is fully interoperable with everything above.
+
+    * Documentation: http://howardhinnant.github.io/date/islamic.html
+
+## Standardization
+
+Slightly modified versions of `"date.h"` and `"tz.h"` were voted into the C++20 working draft at the Jacksonville FL meeting on 2018-03-17:
+
+* http://howardhinnant.github.io/date/d0355r7.html
+
+## Build & Test
+
+You can download and install Date using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    vcpkg install date
+
+The Date port in vcpkg is updated by Microsoft team members and community contributors. If the version falls behind, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+
+You can optionally build using [CMake](https://cmake.org/). Here is a guide of how to build and test using the CMake Makefile generator.
+
+```bash
+mkdir build
+cd build
+cmake ../
+cmake --build . --target testit # Consider '-- -j4' for multithreading
+```
+## Projects using this library
+
+* www.safe.com
+* www.webtoolkit.eu/wt
+* https://github.com/ViewTouch/viewtouch
+* https://routinghub.com
+* https://github.com/valhalla
+
+If you would like your project (or product) on this list, just let me know.

TimeZoneMappings.csv

@@ -1,453 +0,0 @@
-Copyright © 1991-2013 Unicode, Inc.
-CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
-For terms of use, see http://www.unicode.org/copyright.html
-
-"AUS Central Standard Time","001","Australia/Darwin"
-"AUS Central Standard Time","AU","Australia/Darwin"
-"AUS Eastern Standard Time","001","Australia/Sydney"
-"AUS Eastern Standard Time","AU","Australia/Sydney Australia/Melbourne"
-"Afghanistan Standard Time","001","Asia/Kabul"
-"Afghanistan Standard Time","AF","Asia/Kabul"
-"Alaskan Standard Time","001","America/Anchorage"
-"Alaskan Standard Time","US","America/Anchorage America/Juneau America/Nome America/Sitka America/Yakutat"
-"Arab Standard Time","001","Asia/Riyadh"
-"Arab Standard Time","BH","Asia/Bahrain"
-"Arab Standard Time","KW","Asia/Kuwait"
-"Arab Standard Time","QA","Asia/Qatar"
-"Arab Standard Time","SA","Asia/Riyadh"
-"Arab Standard Time","YE","Asia/Aden"
-"Arabian Standard Time","001","Asia/Dubai"
-"Arabian Standard Time","AE","Asia/Dubai"
-"Arabian Standard Time","OM","Asia/Muscat"
-"Arabian Standard Time","ZZ","Etc/GMT-4"
-"Arabic Standard Time","001","Asia/Baghdad"
-"Arabic Standard Time","IQ","Asia/Baghdad"
-"Argentina Standard Time","001","America/Buenos_Aires"
-"Argentina Standard Time","AR","America/Buenos_Aires America/Argentina/La_Rioja America/Argentina/Rio_Gallegos America/Argentina/Salta America/Argentina/San_Juan America/Argentina/San_Luis America/Argentina/Tucuman America/Argentina/Ushuaia America/Catamarca America/Cordoba America/Jujuy America/Mendoza"
-"Atlantic Standard Time","001","America/Halifax"
-"Atlantic Standard Time","BM","Atlantic/Bermuda"
-"Atlantic Standard Time","CA","America/Halifax America/Glace_Bay America/Goose_Bay America/Moncton"
-"Atlantic Standard Time","GL","America/Thule"
-"Azerbaijan Standard Time","001","Asia/Baku"
-"Azerbaijan Standard Time","AZ","Asia/Baku"
-"Azores Standard Time","001","Atlantic/Azores"
-"Azores Standard Time","GL","America/Scoresbysund"
-"Azores Standard Time","PT","Atlantic/Azores"
-"Bahia Standard Time","001","America/Bahia"
-"Bahia Standard Time","BR","America/Bahia"
-"Bangladesh Standard Time","001","Asia/Dhaka"
-"Bangladesh Standard Time","BD","Asia/Dhaka"
-"Bangladesh Standard Time","BT","Asia/Thimphu"
-"Belarus Standard Time","001","Europe/Minsk"
-"Belarus Standard Time","BY","Europe/Minsk"
-"Canada Central Standard Time","001","America/Regina"
-"Canada Central Standard Time","CA","America/Regina America/Swift_Current"
-"Cape Verde Standard Time","001","Atlantic/Cape_Verde"
-"Cape Verde Standard Time","CV","Atlantic/Cape_Verde"
-"Cape Verde Standard Time","ZZ","Etc/GMT+1"
-"Caucasus Standard Time","001","Asia/Yerevan"
-"Caucasus Standard Time","AM","Asia/Yerevan"
-"Cen. Australia Standard Time","001","Australia/Adelaide"
-"Cen. Australia Standard Time","AU","Australia/Adelaide Australia/Broken_Hill"
-"Central America Standard Time","001","America/Guatemala"
-"Central America Standard Time","BZ","America/Belize"
-"Central America Standard Time","CR","America/Costa_Rica"
-"Central America Standard Time","EC","Pacific/Galapagos"
-"Central America Standard Time","GT","America/Guatemala"
-"Central America Standard Time","HN","America/Tegucigalpa"
-"Central America Standard Time","NI","America/Managua"
-"Central America Standard Time","SV","America/El_Salvador"
-"Central America Standard Time","ZZ","Etc/GMT+6"
-"Central Asia Standard Time","001","Asia/Almaty"
-"Central Asia Standard Time","AQ","Antarctica/Vostok"
-"Central Asia Standard Time","CN","Asia/Urumqi"
-"Central Asia Standard Time","IO","Indian/Chagos"
-"Central Asia Standard Time","KG","Asia/Bishkek"
-"Central Asia Standard Time","KZ","Asia/Almaty Asia/Qyzylorda"
-"Central Asia Standard Time","ZZ","Etc/GMT-6"
-"Central Brazilian Standard Time","001","America/Cuiaba"
-"Central Brazilian Standard Time","BR","America/Cuiaba America/Campo_Grande"
-"Central Europe Standard Time","001","Europe/Budapest"
-"Central Europe Standard Time","AL","Europe/Tirane"
-"Central Europe Standard Time","CZ","Europe/Prague"
-"Central Europe Standard Time","HU","Europe/Budapest"
-"Central Europe Standard Time","ME","Europe/Podgorica"
-"Central Europe Standard Time","RS","Europe/Belgrade"
-"Central Europe Standard Time","SI","Europe/Ljubljana"
-"Central Europe Standard Time","SK","Europe/Bratislava"
-"Central European Standard Time","001","Europe/Warsaw"
-"Central European Standard Time","BA","Europe/Sarajevo"
-"Central European Standard Time","HR","Europe/Zagreb"
-"Central European Standard Time","MK","Europe/Skopje"
-"Central European Standard Time","PL","Europe/Warsaw"
-"Central Pacific Standard Time","001","Pacific/Guadalcanal"
-"Central Pacific Standard Time","AU","Antarctica/Macquarie"
-"Central Pacific Standard Time","FM","Pacific/Ponape Pacific/Kosrae"
-"Central Pacific Standard Time","NC","Pacific/Noumea"
-"Central Pacific Standard Time","PG","Pacific/Bougainville"
-"Central Pacific Standard Time","SB","Pacific/Guadalcanal"
-"Central Pacific Standard Time","VU","Pacific/Efate"
-"Central Pacific Standard Time","ZZ","Etc/GMT-11"
-"Central Standard Time","001","America/Chicago"
-"Central Standard Time","CA","America/Winnipeg America/Rainy_River America/Rankin_Inlet America/Resolute"
-"Central Standard Time","MX","America/Matamoros"
-"Central Standard Time","US","America/Chicago America/Indiana/Knox America/Indiana/Tell_City America/Menominee America/North_Dakota/Beulah America/North_Dakota/Center America/North_Dakota/New_Salem"
-"Central Standard Time","ZZ","CST6CDT"
-"Central Standard Time (Mexico)","001","America/Mexico_City"
-"Central Standard Time (Mexico)","MX","America/Mexico_City America/Bahia_Banderas America/Merida America/Monterrey"
-"China Standard Time","001","Asia/Shanghai"
-"China Standard Time","CN","Asia/Shanghai"
-"China Standard Time","HK","Asia/Hong_Kong"
-"China Standard Time","MO","Asia/Macau"
-"Dateline Standard Time","001","Etc/GMT+12"
-"Dateline Standard Time","ZZ","Etc/GMT+12"
-"E. Africa Standard Time","001","Africa/Nairobi"
-"E. Africa Standard Time","AQ","Antarctica/Syowa"
-"E. Africa Standard Time","DJ","Africa/Djibouti"
-"E. Africa Standard Time","ER","Africa/Asmera"
-"E. Africa Standard Time","ET","Africa/Addis_Ababa"
-"E. Africa Standard Time","KE","Africa/Nairobi"
-"E. Africa Standard Time","KM","Indian/Comoro"
-"E. Africa Standard Time","MG","Indian/Antananarivo"
-"E. Africa Standard Time","SD","Africa/Khartoum"
-"E. Africa Standard Time","SO","Africa/Mogadishu"
-"E. Africa Standard Time","SS","Africa/Juba"
-"E. Africa Standard Time","TZ","Africa/Dar_es_Salaam"
-"E. Africa Standard Time","UG","Africa/Kampala"
-"E. Africa Standard Time","YT","Indian/Mayotte"
-"E. Africa Standard Time","ZZ","Etc/GMT-3"
-"E. Australia Standard Time","001","Australia/Brisbane"
-"E. Australia Standard Time","AU","Australia/Brisbane Australia/Lindeman"
-"E. South America Standard Time","001","America/Sao_Paulo"
-"E. South America Standard Time","BR","America/Sao_Paulo"
-"Eastern Standard Time","001","America/New_York"
-"Eastern Standard Time","BS","America/Nassau"
-"Eastern Standard Time","CA","America/Toronto America/Iqaluit America/Montreal America/Nipigon America/Pangnirtung America/Thunder_Bay"
-"Eastern Standard Time","CU","America/Havana"
-"Eastern Standard Time","HT","America/Port-au-Prince"
-"Eastern Standard Time","US","America/New_York America/Detroit America/Indiana/Petersburg America/Indiana/Vincennes America/Indiana/Winamac America/Kentucky/Monticello America/Louisville"
-"Eastern Standard Time","ZZ","EST5EDT"
-"Eastern Standard Time (Mexico)","001","America/Cancun"
-"Eastern Standard Time (Mexico)","MX","America/Cancun"
-"Egypt Standard Time","001","Africa/Cairo"
-"Egypt Standard Time","EG","Africa/Cairo"
-"Ekaterinburg Standard Time","001","Asia/Yekaterinburg"
-"Ekaterinburg Standard Time","RU","Asia/Yekaterinburg"
-"FLE Standard Time","001","Europe/Kiev"
-"FLE Standard Time","AX","Europe/Mariehamn"
-"FLE Standard Time","BG","Europe/Sofia"
-"FLE Standard Time","EE","Europe/Tallinn"
-"FLE Standard Time","FI","Europe/Helsinki"
-"FLE Standard Time","LT","Europe/Vilnius"
-"FLE Standard Time","LV","Europe/Riga"
-"FLE Standard Time","UA","Europe/Kiev Europe/Uzhgorod Europe/Zaporozhye"
-"Fiji Standard Time","001","Pacific/Fiji"
-"Fiji Standard Time","FJ","Pacific/Fiji"
-"GMT Standard Time","001","Europe/London"
-"GMT Standard Time","ES","Atlantic/Canary"
-"GMT Standard Time","FO","Atlantic/Faeroe"
-"GMT Standard Time","GB","Europe/London"
-"GMT Standard Time","GG","Europe/Guernsey"
-"GMT Standard Time","IE","Europe/Dublin"
-"GMT Standard Time","IM","Europe/Isle_of_Man"
-"GMT Standard Time","JE","Europe/Jersey"
-"GMT Standard Time","PT","Europe/Lisbon Atlantic/Madeira"
-"GTB Standard Time","001","Europe/Bucharest"
-"GTB Standard Time","CY","Asia/Nicosia"
-"GTB Standard Time","GR","Europe/Athens"
-"GTB Standard Time","MD","Europe/Chisinau"
-"GTB Standard Time","RO","Europe/Bucharest"
-"Georgian Standard Time","001","Asia/Tbilisi"
-"Georgian Standard Time","GE","Asia/Tbilisi"
-"Greenland Standard Time","001","America/Godthab"
-"Greenland Standard Time","GL","America/Godthab"
-"Greenwich Standard Time","001","Atlantic/Reykjavik"
-"Greenwich Standard Time","BF","Africa/Ouagadougou"
-"Greenwich Standard Time","CI","Africa/Abidjan"
-"Greenwich Standard Time","GH","Africa/Accra"
-"Greenwich Standard Time","GM","Africa/Banjul"
-"Greenwich Standard Time","GN","Africa/Conakry"
-"Greenwich Standard Time","GW","Africa/Bissau"
-"Greenwich Standard Time","IS","Atlantic/Reykjavik"
-"Greenwich Standard Time","LR","Africa/Monrovia"
-"Greenwich Standard Time","ML","Africa/Bamako"
-"Greenwich Standard Time","MR","Africa/Nouakchott"
-"Greenwich Standard Time","SH","Atlantic/St_Helena"
-"Greenwich Standard Time","SL","Africa/Freetown"
-"Greenwich Standard Time","SN","Africa/Dakar"
-"Greenwich Standard Time","ST","Africa/Sao_Tome"
-"Greenwich Standard Time","TG","Africa/Lome"
-"Hawaiian Standard Time","001","Pacific/Honolulu"
-"Hawaiian Standard Time","CK","Pacific/Rarotonga"
-"Hawaiian Standard Time","PF","Pacific/Tahiti"
-"Hawaiian Standard Time","UM","Pacific/Johnston"
-"Hawaiian Standard Time","US","Pacific/Honolulu"
-"Hawaiian Standard Time","ZZ","Etc/GMT+10"
-"India Standard Time","001","Asia/Calcutta"
-"India Standard Time","IN","Asia/Calcutta"
-"Iran Standard Time","001","Asia/Tehran"
-"Iran Standard Time","IR","Asia/Tehran"
-"Israel Standard Time","001","Asia/Jerusalem"
-"Israel Standard Time","IL","Asia/Jerusalem"
-"Jordan Standard Time","001","Asia/Amman"
-"Jordan Standard Time","JO","Asia/Amman"
-"Kaliningrad Standard Time","001","Europe/Kaliningrad"
-"Kaliningrad Standard Time","RU","Europe/Kaliningrad"
-"Korea Standard Time","001","Asia/Seoul"
-"Korea Standard Time","KP","Asia/Pyongyang"
-"Korea Standard Time","KR","Asia/Seoul"
-"Libya Standard Time","001","Africa/Tripoli"
-"Libya Standard Time","LY","Africa/Tripoli"
-"Line Islands Standard Time","001","Pacific/Kiritimati"
-"Line Islands Standard Time","KI","Pacific/Kiritimati"
-"Line Islands Standard Time","ZZ","Etc/GMT-14"
-"Magadan Standard Time","001","Asia/Magadan"
-"Magadan Standard Time","RU","Asia/Magadan"
-"Mauritius Standard Time","001","Indian/Mauritius"
-"Mauritius Standard Time","MU","Indian/Mauritius"
-"Mauritius Standard Time","RE","Indian/Reunion"
-"Mauritius Standard Time","SC","Indian/Mahe"
-"Middle East Standard Time","001","Asia/Beirut"
-"Middle East Standard Time","LB","Asia/Beirut"
-"Montevideo Standard Time","001","America/Montevideo"
-"Montevideo Standard Time","UY","America/Montevideo"
-"Morocco Standard Time","001","Africa/Casablanca"
-"Morocco Standard Time","EH","Africa/El_Aaiun"
-"Morocco Standard Time","MA","Africa/Casablanca"
-"Mountain Standard Time","001","America/Denver"
-"Mountain Standard Time","CA","America/Edmonton America/Cambridge_Bay America/Inuvik America/Yellowknife"
-"Mountain Standard Time","MX","America/Ojinaga"
-"Mountain Standard Time","US","America/Denver America/Boise"
-"Mountain Standard Time","ZZ","MST7MDT"
-"Mountain Standard Time (Mexico)","001","America/Chihuahua"
-"Mountain Standard Time (Mexico)","MX","America/Chihuahua America/Mazatlan"
-"Myanmar Standard Time","001","Asia/Rangoon"
-"Myanmar Standard Time","CC","Indian/Cocos"
-"Myanmar Standard Time","MM","Asia/Rangoon"
-"N. Central Asia Standard Time","001","Asia/Novosibirsk"
-"N. Central Asia Standard Time","RU","Asia/Novosibirsk Asia/Omsk"
-"Namibia Standard Time","001","Africa/Windhoek"
-"Namibia Standard Time","NA","Africa/Windhoek"
-"Nepal Standard Time","001","Asia/Katmandu"
-"Nepal Standard Time","NP","Asia/Katmandu"
-"New Zealand Standard Time","001","Pacific/Auckland"
-"New Zealand Standard Time","AQ","Antarctica/McMurdo"
-"New Zealand Standard Time","NZ","Pacific/Auckland"
-"Newfoundland Standard Time","001","America/St_Johns"
-"Newfoundland Standard Time","CA","America/St_Johns"
-"North Asia East Standard Time","001","Asia/Irkutsk"
-"North Asia East Standard Time","RU","Asia/Irkutsk Asia/Chita"
-"North Asia Standard Time","001","Asia/Krasnoyarsk"
-"North Asia Standard Time","RU","Asia/Krasnoyarsk Asia/Novokuznetsk"
-"Pacific SA Standard Time","001","America/Santiago"
-"Pacific SA Standard Time","AQ","Antarctica/Palmer"
-"Pacific SA Standard Time","CL","America/Santiago"
-"Pacific Standard Time","001","America/Los_Angeles"
-"Pacific Standard Time","CA","America/Vancouver America/Dawson America/Whitehorse"
-"Pacific Standard Time","MX","America/Tijuana"
-"Pacific Standard Time","US","America/Los_Angeles"
-"Pacific Standard Time","ZZ","PST8PDT"
-"Pacific Standard Time (Mexico)","001","America/Santa_Isabel"
-"Pacific Standard Time (Mexico)","MX","America/Santa_Isabel"
-"Pakistan Standard Time","001","Asia/Karachi"
-"Pakistan Standard Time","PK","Asia/Karachi"
-"Paraguay Standard Time","001","America/Asuncion"
-"Paraguay Standard Time","PY","America/Asuncion"
-"Romance Standard Time","001","Europe/Paris"
-"Romance Standard Time","BE","Europe/Brussels"
-"Romance Standard Time","DK","Europe/Copenhagen"
-"Romance Standard Time","ES","Europe/Madrid Africa/Ceuta"
-"Romance Standard Time","FR","Europe/Paris"
-"Russia Time Zone 10","001","Asia/Srednekolymsk"
-"Russia Time Zone 10","RU","Asia/Srednekolymsk"
-"Russia Time Zone 11","001","Asia/Kamchatka"
-"Russia Time Zone 11","RU","Asia/Kamchatka Asia/Anadyr"
-"Russia Time Zone 3","001","Europe/Samara"
-"Russia Time Zone 3","RU","Europe/Samara"
-"Russian Standard Time","001","Europe/Moscow"
-"Russian Standard Time","RU","Europe/Moscow Europe/Simferopol Europe/Volgograd"
-"SA Eastern Standard Time","001","America/Cayenne"
-"SA Eastern Standard Time","AQ","Antarctica/Rothera"
-"SA Eastern Standard Time","BR","America/Fortaleza America/Araguaina America/Belem America/Maceio America/Recife America/Santarem"
-"SA Eastern Standard Time","FK","Atlantic/Stanley"
-"SA Eastern Standard Time","GF","America/Cayenne"
-"SA Eastern Standard Time","SR","America/Paramaribo"
-"SA Eastern Standard Time","ZZ","Etc/GMT+3"
-"SA Pacific Standard Time","001","America/Bogota"
-"SA Pacific Standard Time","BR","America/Rio_Branco America/Eirunepe"
-"SA Pacific Standard Time","CA","America/Coral_Harbour"
-"SA Pacific Standard Time","CO","America/Bogota"
-"SA Pacific Standard Time","EC","America/Guayaquil"
-"SA Pacific Standard Time","JM","America/Jamaica"
-"SA Pacific Standard Time","KY","America/Cayman"
-"SA Pacific Standard Time","PA","America/Panama"
-"SA Pacific Standard Time","PE","America/Lima"
-"SA Pacific Standard Time","ZZ","Etc/GMT+5"
-"SA Western Standard Time","001","America/La_Paz"
-"SA Western Standard Time","AG","America/Antigua"
-"SA Western Standard Time","AI","America/Anguilla"
-"SA Western Standard Time","AW","America/Aruba"
-"SA Western Standard Time","BB","America/Barbados"
-"SA Western Standard Time","BL","America/St_Barthelemy"
-"SA Western Standard Time","BO","America/La_Paz"
-"SA Western Standard Time","BQ","America/Kralendijk"
-"SA Western Standard Time","BR","America/Manaus America/Boa_Vista America/Porto_Velho"
-"SA Western Standard Time","CA","America/Blanc-Sablon"
-"SA Western Standard Time","CW","America/Curacao"
-"SA Western Standard Time","DM","America/Dominica"
-"SA Western Standard Time","DO","America/Santo_Domingo"
-"SA Western Standard Time","GD","America/Grenada"
-"SA Western Standard Time","GP","America/Guadeloupe"
-"SA Western Standard Time","GY","America/Guyana"
-"SA Western Standard Time","KN","America/St_Kitts"
-"SA Western Standard Time","LC","America/St_Lucia"
-"SA Western Standard Time","MF","America/Marigot"
-"SA Western Standard Time","MQ","America/Martinique"
-"SA Western Standard Time","MS","America/Montserrat"
-"SA Western Standard Time","PR","America/Puerto_Rico"
-"SA Western Standard Time","SX","America/Lower_Princes"
-"SA Western Standard Time","TC","America/Grand_Turk"
-"SA Western Standard Time","TT","America/Port_of_Spain"
-"SA Western Standard Time","VC","America/St_Vincent"
-"SA Western Standard Time","VG","America/Tortola"
-"SA Western Standard Time","VI","America/St_Thomas"
-"SA Western Standard Time","ZZ","Etc/GMT+4"
-"SE Asia Standard Time","001","Asia/Bangkok"
-"SE Asia Standard Time","AQ","Antarctica/Davis"
-"SE Asia Standard Time","CX","Indian/Christmas"
-"SE Asia Standard Time","ID","Asia/Jakarta Asia/Pontianak"
-"SE Asia Standard Time","KH","Asia/Phnom_Penh"
-"SE Asia Standard Time","LA","Asia/Vientiane"
-"SE Asia Standard Time","MN","Asia/Hovd"
-"SE Asia Standard Time","TH","Asia/Bangkok"
-"SE Asia Standard Time","VN","Asia/Saigon"
-"SE Asia Standard Time","ZZ","Etc/GMT-7"
-"Samoa Standard Time","001","Pacific/Apia"
-"Samoa Standard Time","WS","Pacific/Apia"
-"Singapore Standard Time","001","Asia/Singapore"
-"Singapore Standard Time","BN","Asia/Brunei"
-"Singapore Standard Time","ID","Asia/Makassar"
-"Singapore Standard Time","MY","Asia/Kuala_Lumpur Asia/Kuching"
-"Singapore Standard Time","PH","Asia/Manila"
-"Singapore Standard Time","SG","Asia/Singapore"
-"Singapore Standard Time","ZZ","Etc/GMT-8"
-"South Africa Standard Time","001","Africa/Johannesburg"
-"South Africa Standard Time","BI","Africa/Bujumbura"
-"South Africa Standard Time","BW","Africa/Gaborone"
-"South Africa Standard Time","CD","Africa/Lubumbashi"
-"South Africa Standard Time","LS","Africa/Maseru"
-"South Africa Standard Time","MW","Africa/Blantyre"
-"South Africa Standard Time","MZ","Africa/Maputo"
-"South Africa Standard Time","RW","Africa/Kigali"
-"South Africa Standard Time","SZ","Africa/Mbabane"
-"South Africa Standard Time","ZA","Africa/Johannesburg"
-"South Africa Standard Time","ZM","Africa/Lusaka"
-"South Africa Standard Time","ZW","Africa/Harare"
-"South Africa Standard Time","ZZ","Etc/GMT-2"
-"Sri Lanka Standard Time","001","Asia/Colombo"
-"Sri Lanka Standard Time","LK","Asia/Colombo"
-"Syria Standard Time","001","Asia/Damascus"
-"Syria Standard Time","SY","Asia/Damascus"
-"Taipei Standard Time","001","Asia/Taipei"
-"Taipei Standard Time","TW","Asia/Taipei"
-"Tasmania Standard Time","001","Australia/Hobart"
-"Tasmania Standard Time","AU","Australia/Hobart Australia/Currie"
-"Tokyo Standard Time","001","Asia/Tokyo"
-"Tokyo Standard Time","ID","Asia/Jayapura"
-"Tokyo Standard Time","JP","Asia/Tokyo"
-"Tokyo Standard Time","PW","Pacific/Palau"
-"Tokyo Standard Time","TL","Asia/Dili"
-"Tokyo Standard Time","ZZ","Etc/GMT-9"
-"Tonga Standard Time","001","Pacific/Tongatapu"
-"Tonga Standard Time","KI","Pacific/Enderbury"
-"Tonga Standard Time","TK","Pacific/Fakaofo"
-"Tonga Standard Time","TO","Pacific/Tongatapu"
-"Tonga Standard Time","ZZ","Etc/GMT-13"
-"Turkey Standard Time","001","Europe/Istanbul"
-"Turkey Standard Time","TR","Europe/Istanbul"
-"US Eastern Standard Time","001","America/Indianapolis"
-"US Eastern Standard Time","US","America/Indianapolis America/Indiana/Marengo America/Indiana/Vevay"
-"US Mountain Standard Time","001","America/Phoenix"
-"US Mountain Standard Time","CA","America/Dawson_Creek America/Creston"
-"US Mountain Standard Time","MX","America/Hermosillo"
-"US Mountain Standard Time","US","America/Phoenix"
-"US Mountain Standard Time","ZZ","Etc/GMT+7"
-"UTC","001","Etc/GMT"
-"UTC","GL","America/Danmarkshavn"
-"UTC","ZZ","Etc/GMT"
-"UTC+12","001","Etc/GMT-12"
-"UTC+12","KI","Pacific/Tarawa"
-"UTC+12","MH","Pacific/Majuro Pacific/Kwajalein"
-"UTC+12","NR","Pacific/Nauru"
-"UTC+12","TV","Pacific/Funafuti"
-"UTC+12","UM","Pacific/Wake"
-"UTC+12","WF","Pacific/Wallis"
-"UTC+12","ZZ","Etc/GMT-12"
-"UTC-02","001","Etc/GMT+2"
-"UTC-02","BR","America/Noronha"
-"UTC-02","GS","Atlantic/South_Georgia"
-"UTC-02","ZZ","Etc/GMT+2"
-"UTC-11","001","Etc/GMT+11"
-"UTC-11","AS","Pacific/Pago_Pago"
-"UTC-11","NU","Pacific/Niue"
-"UTC-11","UM","Pacific/Midway"
-"UTC-11","ZZ","Etc/GMT+11"
-"Ulaanbaatar Standard Time","001","Asia/Ulaanbaatar"
-"Ulaanbaatar Standard Time","MN","Asia/Ulaanbaatar Asia/Choibalsan"
-"Venezuela Standard Time","001","America/Caracas"
-"Venezuela Standard Time","VE","America/Caracas"
-"Vladivostok Standard Time","001","Asia/Vladivostok"
-"Vladivostok Standard Time","RU","Asia/Vladivostok Asia/Sakhalin Asia/Ust-Nera"
-"W. Australia Standard Time","001","Australia/Perth"
-"W. Australia Standard Time","AQ","Antarctica/Casey"
-"W. Australia Standard Time","AU","Australia/Perth"
-"W. Central Africa Standard Time","001","Africa/Lagos"
-"W. Central Africa Standard Time","AO","Africa/Luanda"
-"W. Central Africa Standard Time","BJ","Africa/Porto-Novo"
-"W. Central Africa Standard Time","CD","Africa/Kinshasa"
-"W. Central Africa Standard Time","CF","Africa/Bangui"
-"W. Central Africa Standard Time","CG","Africa/Brazzaville"
-"W. Central Africa Standard Time","CM","Africa/Douala"
-"W. Central Africa Standard Time","DZ","Africa/Algiers"
-"W. Central Africa Standard Time","GA","Africa/Libreville"
-"W. Central Africa Standard Time","GQ","Africa/Malabo"
-"W. Central Africa Standard Time","NE","Africa/Niamey"
-"W. Central Africa Standard Time","NG","Africa/Lagos"
-"W. Central Africa Standard Time","TD","Africa/Ndjamena"
-"W. Central Africa Standard Time","TN","Africa/Tunis"
-"W. Central Africa Standard Time","ZZ","Etc/GMT-1"
-"W. Europe Standard Time","001","Europe/Berlin"
-"W. Europe Standard Time","AD","Europe/Andorra"
-"W. Europe Standard Time","AT","Europe/Vienna"
-"W. Europe Standard Time","CH","Europe/Zurich"
-"W. Europe Standard Time","DE","Europe/Berlin Europe/Busingen"
-"W. Europe Standard Time","GI","Europe/Gibraltar"
-"W. Europe Standard Time","IT","Europe/Rome"
-"W. Europe Standard Time","LI","Europe/Vaduz"
-"W. Europe Standard Time","LU","Europe/Luxembourg"
-"W. Europe Standard Time","MC","Europe/Monaco"
-"W. Europe Standard Time","MT","Europe/Malta"
-"W. Europe Standard Time","NL","Europe/Amsterdam"
-"W. Europe Standard Time","NO","Europe/Oslo"
-"W. Europe Standard Time","SE","Europe/Stockholm"
-"W. Europe Standard Time","SJ","Arctic/Longyearbyen"
-"W. Europe Standard Time","SM","Europe/San_Marino"
-"W. Europe Standard Time","VA","Europe/Vatican"
-"West Asia Standard Time","001","Asia/Tashkent"
-"West Asia Standard Time","AQ","Antarctica/Mawson"
-"West Asia Standard Time","KZ","Asia/Oral Asia/Aqtau Asia/Aqtobe"
-"West Asia Standard Time","MV","Indian/Maldives"
-"West Asia Standard Time","TF","Indian/Kerguelen"
-"West Asia Standard Time","TJ","Asia/Dushanbe"
-"West Asia Standard Time","TM","Asia/Ashgabat"
-"West Asia Standard Time","UZ","Asia/Tashkent Asia/Samarkand"
-"West Asia Standard Time","ZZ","Etc/GMT-5"
-"West Pacific Standard Time","001","Pacific/Port_Moresby"
-"West Pacific Standard Time","AQ","Antarctica/DumontDUrville"
-"West Pacific Standard Time","FM","Pacific/Truk"
-"West Pacific Standard Time","GU","Pacific/Guam"
-"West Pacific Standard Time","MP","Pacific/Saipan"
-"West Pacific Standard Time","PG","Pacific/Port_Moresby"
-"West Pacific Standard Time","ZZ","Etc/GMT-10"
-"Yakutsk Standard Time","001","Asia/Yakutsk"
-"Yakutsk Standard Time","RU","Asia/Yakutsk Asia/Khandyga"

ci/install_cmake.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -e
+
+IFS=. read cm_maj cm_min cm_rel <<<"$1"
+: ${cm_rel:-0}
+CMAKE_ROOT=${2:-"${HOME}/cmake"}
+
+function cmake_version ()
+{
+    if [[ -d ${CMAKE_ROOT} ]] ; then
+        local perms=$(test $(uname) = "Linux" && echo "/111" || echo "+111")
+        local installed=$(find ${CMAKE_ROOT} -perm ${perms} -type f -name cmake)
+        if [[ "${installed}" != "" ]] ; then
+            echo "$(${installed} --version | head -1)"
+        fi
+    fi
+}
+
+installed=$(cmake_version)
+if [[ "${installed}" != "" && ${installed} =~ ${cm_maj}.${cm_min}.${cm_rel} ]] ; then
+    echo "cmake already installed: ${installed}"
+    exit
+fi
+
+pkgname="cmake-${cm_maj}.${cm_min}.${cm_rel}-$(uname)-x86_64.tar.gz"
+tmppkg="/tmp/cmake.tar.gz"
+wget --quiet https://cmake.org/files/v${cm_maj}.${cm_min}/${pkgname} -O ${tmppkg}
+mkdir -p ${CMAKE_ROOT}
+cd ${CMAKE_ROOT}
+tar --strip-components 1 -xf ${tmppkg}
+rm -f ${tmppkg}
+echo "installed: $(cmake_version)"
+
+

cmake/dateConfig.cmake

@@ -0,0 +1,11 @@
+include( CMakeFindDependencyMacro )
+include( "${CMAKE_CURRENT_LIST_DIR}/dateTargets.cmake" )
+if( NOT MSVC AND TARGET date::tz )
+    find_dependency( Threads REQUIRED)
+    get_target_property( _tzill date::tz  INTERFACE_LINK_LIBRARIES )
+    if( _tzill AND "${_tzill}" MATCHES "libcurl" )
+        find_dependency( CURL )
+    endif( )
+endif( )
+
+

compile_fail.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+export TEST_BIN_NAME=$1
+#echo "Building ${TEST_BIN_NAME}"
+shift 1
+export BUILD_COMMAND=$@
+#echo "Build command: ${BUILD_COMMAND}"
+eval ${BUILD_COMMAND} >/dev/null 2>/dev/null
+
+if [ $? -eq 0 ]; then
+	echo -ne "#!/bin/bash\nexit 1;" > ${TEST_BIN_NAME}
+else
+	echo -ne "#!/bin/bash\nexit 0;" > ${TEST_BIN_NAME}
+fi
+chmod u+x ${TEST_BIN_NAME}
+exit 0;
+

include/date/chrono_io.h

@@ -0,0 +1,34 @@
+#ifndef CHRONO_IO_H
+#define CHRONO_IO_H
+
+// The MIT License (MIT)
+//
+// Copyright (c) 2016, 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+//
+// Our apologies.  When the previous paragraph was written, lowercase had not yet
+// been invented (that would involve another several millennia of evolution).
+// We did not mean to shout.
+
+// This functionality has moved to "date.h"
+
+#include "date.h"
+
+#endif  // CHRONO_IO_H

include/date/ios.h

@@ -0,0 +1,50 @@
+//
+//  ios.h
+//  DateTimeLib
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Alexander Kormanovsky
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#ifndef ios_hpp
+#define ios_hpp
+
+#if __APPLE__
+# include <TargetConditionals.h>
+# if TARGET_OS_IPHONE
+#   include <string>
+
+    namespace date
+    {
+    namespace iOSUtils
+    {
+    
+    std::string get_tzdata_path();
+    std::string get_current_timezone();
+    
+    }  // namespace iOSUtils
+    }  // namespace date
+
+# endif  // TARGET_OS_IPHONE
+#else   // !__APPLE__
+# define TARGET_OS_IPHONE 0
+#endif  // !__APPLE__
+#endif // ios_hpp

include/date/iso_week.h

@@ -2,19 +2,19 @@
 #define ISO_WEEK_H
 
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016, 2017 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -25,6 +25,8 @@
 
 #include "date.h"
 
+#include <climits>
+
 namespace iso_week
 {
 
@@ -38,7 +40,8 @@ using years = date::years;
 
 // time_point
 
-using day_point = date::day_point;
+using sys_days = date::sys_days;
+using local_days = date::local_days;
 
 // types
 
@@ -95,7 +98,8 @@ public:
     explicit CONSTCD11 weekday(unsigned wd) NOEXCEPT;
     CONSTCD11 weekday(date::weekday wd) NOEXCEPT;
     explicit weekday(int) = delete;
-    CONSTCD11 weekday(const day_point& dp) NOEXCEPT;
+    CONSTCD11 weekday(const sys_days& dp) NOEXCEPT;
+    CONSTCD11 explicit weekday(const local_days& dp) NOEXCEPT;
 
     weekday& operator++()    NOEXCEPT;
     weekday  operator++(int) NOEXCEPT;
@@ -123,7 +127,9 @@ CONSTCD14 weekday operator+(const days&    x, const weekday& y) NOEXCEPT;
 CONSTCD14 weekday operator-(const weekday& x, const days&    y) NOEXCEPT;
 CONSTCD14 days    operator-(const weekday& x, const weekday& y) NOEXCEPT;
 
-std::ostream& operator<<(std::ostream& os, const weekday& wd);
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const weekday& wd);
 
 // year
 
@@ -161,7 +167,9 @@ CONSTCD11 year  operator+(const years& x, const year&  y) NOEXCEPT;
 CONSTCD11 year  operator-(const year&  x, const years& y) NOEXCEPT;
 CONSTCD11 years operator-(const year&  x, const year&  y) NOEXCEPT;
 
-std::ostream& operator<<(std::ostream& os, const year& y);
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year& y);
 
 // weeknum
 
@@ -196,7 +204,9 @@ CONSTCD11 weeknum  operator+(const weeks&   x, const weeknum& y) NOEXCEPT;
 CONSTCD11 weeknum  operator-(const weeknum& x, const weeks&   y) NOEXCEPT;
 CONSTCD11 weeks    operator-(const weeknum& x, const weeknum& y) NOEXCEPT;
 
-std::ostream& operator<<(std::ostream& os, const weeknum& wn);
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const weeknum& wn);
 
 // year_weeknum
 
@@ -228,7 +238,9 @@ CONSTCD11 year_weeknum operator+(const year_weeknum& ym, const years& dy) NOEXCE
 CONSTCD11 year_weeknum operator+(const years& dy, const year_weeknum& ym) NOEXCEPT;
 CONSTCD11 year_weeknum operator-(const year_weeknum& ym, const years& dy) NOEXCEPT;
 
-std::ostream& operator<<(std::ostream& os, const year_weeknum& ym);
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_weeknum& ym);
 
 // year_lastweek
 
@@ -259,7 +271,9 @@ CONSTCD11 year_lastweek operator+(const year_lastweek& ym, const years& dy) NOEX
 CONSTCD11 year_lastweek operator+(const years& dy, const year_lastweek& ym) NOEXCEPT;
 CONSTCD11 year_lastweek operator-(const year_lastweek& ym, const years& dy) NOEXCEPT;
 
-std::ostream& operator<<(std::ostream& os, const year_lastweek& ym);
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_lastweek& ym);
 
 // weeknum_weekday
 
@@ -285,7 +299,9 @@ CONSTCD11 bool operator> (const weeknum_weekday& x, const weeknum_weekday& y) NO
 CONSTCD11 bool operator<=(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT;
 CONSTCD11 bool operator>=(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT;
 
-std::ostream& operator<<(std::ostream& os, const weeknum_weekday& md);
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const weeknum_weekday& md);
 
 // lastweek_weekday
 
@@ -308,7 +324,9 @@ CONSTCD11 bool operator> (const lastweek_weekday& x, const lastweek_weekday& y)
 CONSTCD11 bool operator<=(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT;
 CONSTCD11 bool operator>=(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT;
 
-std::ostream& operator<<(std::ostream& os, const lastweek_weekday& md);
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const lastweek_weekday& md);
 
 // year_lastweek_weekday
 
@@ -325,10 +343,11 @@ public:
     year_lastweek_weekday& operator-=(const years& y) NOEXCEPT;
 
     CONSTCD11 iso_week::year    year()    const NOEXCEPT;
-    CONSTCD11 iso_week::weeknum weeknum() const NOEXCEPT;
+    CONSTCD14 iso_week::weeknum weeknum() const NOEXCEPT;
     CONSTCD11 iso_week::weekday weekday() const NOEXCEPT;
 
-    CONSTCD14 operator day_point() const NOEXCEPT;
+    CONSTCD14 operator sys_days() const NOEXCEPT;
+    CONSTCD14 explicit operator local_days() const NOEXCEPT;
     CONSTCD11 bool ok() const NOEXCEPT;
 };
 
@@ -343,7 +362,9 @@ CONSTCD11 year_lastweek_weekday operator+(const year_lastweek_weekday& ywnwd, co
 CONSTCD11 year_lastweek_weekday operator+(const years& y, const year_lastweek_weekday& ywnwd) NOEXCEPT;
 CONSTCD11 year_lastweek_weekday operator-(const year_lastweek_weekday& ywnwd, const years& y) NOEXCEPT;
 
-std::ostream& operator<<(std::ostream& os, const year_lastweek_weekday& ywnwd);
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_lastweek_weekday& ywnwd);
 
 // class year_weeknum_weekday
 
@@ -357,7 +378,8 @@ public:
     CONSTCD11 year_weeknum_weekday(const iso_week::year& y, const iso_week::weeknum& wn,
                                    const iso_week::weekday& wd) NOEXCEPT;
     CONSTCD14 year_weeknum_weekday(const year_lastweek_weekday& ylwwd) NOEXCEPT;
-    CONSTCD14 year_weeknum_weekday(const day_point& dp) NOEXCEPT;
+    CONSTCD14 year_weeknum_weekday(const sys_days& dp) NOEXCEPT;
+    CONSTCD14 explicit year_weeknum_weekday(const local_days& dp) NOEXCEPT;
 
     year_weeknum_weekday& operator+=(const years& y) NOEXCEPT;
     year_weeknum_weekday& operator-=(const years& y) NOEXCEPT;
@@ -366,11 +388,12 @@ public:
     CONSTCD11 iso_week::weeknum weeknum() const NOEXCEPT;
     CONSTCD11 iso_week::weekday weekday() const NOEXCEPT;
 
-    CONSTCD14 operator day_point() const NOEXCEPT;
+    CONSTCD14 operator sys_days() const NOEXCEPT;
+    CONSTCD14 explicit operator local_days() const NOEXCEPT;
     CONSTCD14 bool ok() const NOEXCEPT;
 
 private:
-    static CONSTCD14 year_weeknum_weekday from_day_point(const day_point& dp) NOEXCEPT;
+    static CONSTCD14 year_weeknum_weekday from_days(days dp) NOEXCEPT;
 };
 
 CONSTCD11 bool operator==(const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT;
@@ -384,7 +407,9 @@ CONSTCD11 year_weeknum_weekday operator+(const year_weeknum_weekday& ywnwd, cons
 CONSTCD11 year_weeknum_weekday operator+(const years& y, const year_weeknum_weekday& ywnwd) NOEXCEPT;
 CONSTCD11 year_weeknum_weekday operator-(const year_weeknum_weekday& ywnwd, const years& y) NOEXCEPT;
 
-std::ostream& operator<<(std::ostream& os, const year_weeknum_weekday& ywnwd);
+template<class CharT, class Traits>
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_weeknum_weekday& ywnwd);
 
 //----------------+
 // Implementation |
@@ -426,12 +451,18 @@ weekday::weekday(unsigned wd) NOEXCEPT
 CONSTCD11
 inline
 weekday::weekday(date::weekday wd) NOEXCEPT
-    : wd_(to_iso_encoding(unsigned{wd}))
+    : wd_(wd.iso_encoding())
     {}
 
 CONSTCD11
 inline
-weekday::weekday(const day_point& dp) NOEXCEPT
+weekday::weekday(const sys_days& dp) NOEXCEPT
+    : wd_(weekday_from_days(dp.time_since_epoch().count()))
+    {}
+
+CONSTCD11
+inline
+weekday::weekday(const local_days& dp) NOEXCEPT
     : wd_(weekday_from_days(dp.time_since_epoch().count()))
     {}
 
@@ -523,9 +554,10 @@ operator-(const weekday& x, const days& y) NOEXCEPT
     return x + -y;
 }
 
+template<class CharT, class Traits>
 inline
-std::ostream&
-operator<<(std::ostream& os, const weekday& wd)
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const weekday& wd)
 {
     switch (static_cast<unsigned>(wd))
     {
@@ -575,7 +607,10 @@ inline
 year
 year::min() NOEXCEPT
 {
-    using namespace std::chrono;
+    using std::chrono::seconds;
+    using std::chrono::minutes;
+    using std::chrono::hours;
+    using std::chrono::duration_cast;
     static_assert(sizeof(seconds)*CHAR_BIT >= 41, "seconds may overflow");
     static_assert(sizeof(hours)*CHAR_BIT >= 30, "hours may overflow");
     return sizeof(minutes)*CHAR_BIT < 34 ?
@@ -588,7 +623,10 @@ inline
 year
 year::max() NOEXCEPT
 {
-    using namespace std::chrono;
+    using std::chrono::seconds;
+    using std::chrono::minutes;
+    using std::chrono::hours;
+    using std::chrono::duration_cast;
     static_assert(sizeof(seconds)*CHAR_BIT >= 41, "seconds may overflow");
     static_assert(sizeof(hours)*CHAR_BIT >= 30, "hours may overflow");
     return sizeof(minutes)*CHAR_BIT < 34 ?
@@ -676,11 +714,12 @@ operator-(const year& x, const years& y) NOEXCEPT
     return year{static_cast<int>(x) - y.count()};
 }
 
+template<class CharT, class Traits>
 inline
-std::ostream&
-operator<<(std::ostream& os, const year& y)
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year& y)
 {
-    date::detail::save_stream _(os);
+    date::detail::save_ostream<CharT, Traits> _(os);
     os.fill('0');
     os.flags(std::ios::dec | std::ios::internal);
     os.width(4 + (y < year{0}));
@@ -837,11 +876,12 @@ operator-(const weeknum& x, const weeks& y) NOEXCEPT
     return x + -y;
 }
 
+template<class CharT, class Traits>
 inline
-std::ostream&
-operator<<(std::ostream& os, const weeknum& wn)
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const weeknum& wn)
 {
-    date::detail::save_stream _(os);
+    date::detail::save_ostream<CharT, Traits> _(os);
     os << 'W';
     os.fill('0');
     os.flags(std::ios::dec | std::ios::right);
@@ -863,7 +903,7 @@ CONSTCD11 inline year year_weeknum::year() const NOEXCEPT {return y_;}
 CONSTCD11 inline weeknum year_weeknum::weeknum() const NOEXCEPT {return wn_;}
 CONSTCD11 inline bool year_weeknum::ok() const NOEXCEPT
 {
-    return y_.ok() && 1u <= unsigned{wn_} && wn_ <= (y_/last).weeknum();
+    return y_.ok() && 1u <= static_cast<unsigned>(wn_) && wn_ <= (y_/last).weeknum();
 }
 
 inline
@@ -956,9 +996,10 @@ operator-(const year_weeknum& ym, const years& dy) NOEXCEPT
     return ym + -dy;
 }
 
+template<class CharT, class Traits>
 inline
-std::ostream&
-operator<<(std::ostream& os, const year_weeknum& ywn)
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_weeknum& ywn)
 {
     return os << ywn.year() << '-' << ywn.weeknum();
 }
@@ -979,10 +1020,10 @@ inline
 weeknum
 year_lastweek::weeknum() const NOEXCEPT
 {
-    const auto y = date::year{int{y_}};
-    const auto s0 = day_point{(y-years{1})/12/date::thu[date::last]};
-    const auto s1 = day_point{y/12/date::thu[date::last]};
-    return iso_week::weeknum(date::trunc<weeks>(s1-s0).count());
+    const auto y = date::year{static_cast<int>(y_)};
+    const auto s0 = sys_days((y-years{1})/12/date::thu[date::last]);
+    const auto s1 = sys_days(y/12/date::thu[date::last]);
+    return iso_week::weeknum(static_cast<unsigned>(date::trunc<weeks>(s1-s0).count()));
 }
 
 CONSTCD11 inline bool year_lastweek::ok() const NOEXCEPT {return y_.ok();}
@@ -1075,9 +1116,10 @@ operator-(const year_lastweek& ym, const years& dy) NOEXCEPT
     return ym + -dy;
 }
 
+template<class CharT, class Traits>
 inline
-std::ostream&
-operator<<(std::ostream& os, const year_lastweek& ywn)
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_lastweek& ywn)
 {
     return os << ywn.year() << "-W last";
 }
@@ -1126,7 +1168,7 @@ operator<(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT
 {
     return x.weeknum() < y.weeknum() ? true
         : (x.weeknum() > y.weeknum() ? false
-        : (unsigned{x.weekday()} < unsigned{y.weekday()}));
+        : (static_cast<unsigned>(x.weekday()) < static_cast<unsigned>(y.weekday())));
 }
 
 CONSTCD11
@@ -1153,9 +1195,10 @@ operator>=(const weeknum_weekday& x, const weeknum_weekday& y) NOEXCEPT
     return !(x < y);
 }
 
+template<class CharT, class Traits>
 inline
-std::ostream&
-operator<<(std::ostream& os, const weeknum_weekday& md)
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const weeknum_weekday& md)
 {
     return os << md.weeknum() << '-' << md.weekday();
 }
@@ -1199,7 +1242,7 @@ inline
 bool
 operator<(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT
 {
-    return unsigned{x.weekday()} < unsigned{y.weekday()};
+    return static_cast<unsigned>(x.weekday()) < static_cast<unsigned>(y.weekday());
 }
 
 CONSTCD11
@@ -1226,9 +1269,10 @@ operator>=(const lastweek_weekday& x, const lastweek_weekday& y) NOEXCEPT
     return !(x < y);
 }
 
+template<class CharT, class Traits>
 inline
-std::ostream&
-operator<<(std::ostream& os, const lastweek_weekday& md)
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const lastweek_weekday& md)
 {
     return os << "W last-" << md.weekday();
 }
@@ -1261,7 +1305,7 @@ year_lastweek_weekday::operator-=(const years& y) NOEXCEPT
 
 CONSTCD11 inline year year_lastweek_weekday::year() const NOEXCEPT {return y_;}
 
-CONSTCD11
+CONSTCD14
 inline
 weeknum
 year_lastweek_weekday::weeknum() const NOEXCEPT
@@ -1273,10 +1317,18 @@ CONSTCD11 inline weekday year_lastweek_weekday::weekday() const NOEXCEPT {return
 
 CONSTCD14
 inline
-year_lastweek_weekday::operator day_point() const NOEXCEPT
+year_lastweek_weekday::operator sys_days() const NOEXCEPT
 {
-    return day_point{date::year{int{y_}}/date::dec/date::thu[date::last]} + (mon - thu)
-         - (mon - wd_);
+    return sys_days(date::year{static_cast<int>(y_)}/date::dec/date::thu[date::last])
+         + (sun - thu) - (sun - wd_);
+}
+
+CONSTCD14
+inline
+year_lastweek_weekday::operator local_days() const NOEXCEPT
+{
+    return local_days(date::year{static_cast<int>(y_)}/date::dec/date::thu[date::last])
+         + (sun - thu) - (sun - wd_);
 }
 
 CONSTCD11
@@ -1310,7 +1362,7 @@ operator<(const year_lastweek_weekday& x, const year_lastweek_weekday& y) NOEXCE
 {
     return x.year() < y.year() ? true
         : (x.year() > y.year() ? false
-        : (unsigned{x.weekday()} < unsigned{y.weekday()}));
+        : (static_cast<unsigned>(x.weekday()) < static_cast<unsigned>(y.weekday())));
 }
 
 CONSTCD11
@@ -1361,9 +1413,10 @@ operator-(const year_lastweek_weekday& ywnwd, const years& y)  NOEXCEPT
     return ywnwd + -y;
 }
 
+template<class CharT, class Traits>
 inline
-std::ostream&
-operator<<(std::ostream& os, const year_lastweek_weekday& ywnwd)
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_lastweek_weekday& ywnwd)
 {
     return os << ywnwd.year() << "-W last-" << ywnwd.weekday();
 }
@@ -1390,8 +1443,14 @@ year_weeknum_weekday::year_weeknum_weekday(const year_lastweek_weekday& ylwwd) N
 
 CONSTCD14
 inline
-year_weeknum_weekday::year_weeknum_weekday(const day_point& dp) NOEXCEPT
-    : year_weeknum_weekday(from_day_point(dp))
+year_weeknum_weekday::year_weeknum_weekday(const sys_days& dp) NOEXCEPT
+    : year_weeknum_weekday(from_days(dp.time_since_epoch()))
+    {}
+
+CONSTCD14
+inline
+year_weeknum_weekday::year_weeknum_weekday(const local_days& dp) NOEXCEPT
+    : year_weeknum_weekday(from_days(dp.time_since_epoch()))
     {}
 
 inline
@@ -1416,10 +1475,18 @@ CONSTCD11 inline weekday year_weeknum_weekday::weekday() const NOEXCEPT {return
 
 CONSTCD14
 inline
-year_weeknum_weekday::operator day_point() const NOEXCEPT
+year_weeknum_weekday::operator sys_days() const NOEXCEPT
 {
-    return day_point{date::year{int{y_}-1}/date::dec/date::thu[date::last]}
-         + (date::mon - date::thu) + weeks{unsigned{wn_}-1} + (wd_ - mon);
+    return sys_days(date::year{static_cast<int>(y_)-1}/date::dec/date::thu[date::last])
+         + (date::mon - date::thu) + weeks{static_cast<unsigned>(wn_)-1} + (wd_ - mon);
+}
+
+CONSTCD14
+inline
+year_weeknum_weekday::operator local_days() const NOEXCEPT
+{
+    return local_days(date::year{static_cast<int>(y_)-1}/date::dec/date::thu[date::last])
+         + (date::mon - date::thu) + weeks{static_cast<unsigned>(wn_)-1} + (wd_ - mon);
 }
 
 CONSTCD14
@@ -1433,18 +1500,20 @@ year_weeknum_weekday::ok() const NOEXCEPT
 CONSTCD14
 inline
 year_weeknum_weekday
-year_weeknum_weekday::from_day_point(const day_point& dp) NOEXCEPT
+year_weeknum_weekday::from_days(days d) NOEXCEPT
 {
+    const auto dp = sys_days{d};
     const auto wd = iso_week::weekday{dp};
     auto y = date::year_month_day{dp + days{3}}.year();
-    auto start = day_point{(y - date::years{1})/date::dec/date::thu[date::last]} + (mon-thu);
+    auto start = sys_days((y - date::years{1})/date::dec/date::thu[date::last]) + (mon-thu);
     if (dp < start)
     {
         --y;
-        start = day_point{(y - date::years{1})/date::dec/date::thu[date::last]} + (mon-thu);
+        start = sys_days((y - date::years{1})/date::dec/date::thu[date::last]) + (mon-thu);
     }
-    const auto wn = iso_week::weeknum(date::trunc<weeks>(dp - start).count() + 1);
-    return {iso_week::year(int{y}), wn, wd};
+    const auto wn = iso_week::weeknum(
+                       static_cast<unsigned>(date::trunc<weeks>(dp - start).count() + 1));
+    return {iso_week::year(static_cast<int>(y)), wn, wd};
 }
 
 CONSTCD11
@@ -1472,7 +1541,7 @@ operator<(const year_weeknum_weekday& x, const year_weeknum_weekday& y) NOEXCEPT
         : (x.year() > y.year() ? false
         : (x.weeknum() < y.weeknum() ? true
         : (x.weeknum() > y.weeknum() ? false
-        : (unsigned{x.weekday()} < unsigned{y.weekday()}))));
+        : (static_cast<unsigned>(x.weekday()) < static_cast<unsigned>(y.weekday())))));
 }
 
 CONSTCD11
@@ -1523,9 +1592,10 @@ operator-(const year_weeknum_weekday& ywnwd, const years& y)  NOEXCEPT
     return ywnwd + -y;
 }
 
+template<class CharT, class Traits>
 inline
-std::ostream&
-operator<<(std::ostream& os, const year_weeknum_weekday& ywnwd)
+std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& os, const year_weeknum_weekday& ywnwd)
 {
     return os << ywnwd.year() << '-' << ywnwd.weeknum() << '-' << ywnwd.weekday();
 }
@@ -1545,7 +1615,7 @@ inline
 year_weeknum
 operator/(const year& y, int wn) NOEXCEPT
 {
-    return y/weeknum(wn);
+    return y/weeknum(static_cast<unsigned>(wn));
 }
 
 CONSTCD11

include/date/ptz.h

@@ -0,0 +1,627 @@
+#ifndef PTZ_H
+#define PTZ_H
+
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+// This header allows Posix-style time zones as specified for TZ here:
+// http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html#tag_08_03
+//
+// Posix::time_zone can be constructed with a posix-style string and then used in
+// a zoned_time like so:
+//
+// zoned_time<system_clock::duration, Posix::time_zone> zt{"EST5EDT,M3.2.0,M11.1.0",
+//                                                         system_clock::now()};
+// or:
+//
+// Posix::time_zone tz{"EST5EDT,M3.2.0,M11.1.0"};
+// zoned_time<system_clock::duration, Posix::time_zone> zt{tz, system_clock::now()};
+//
+// Note, Posix-style time zones are not recommended for all of the reasons described here:
+// https://stackoverflow.com/tags/timezone/info
+//
+// They are provided here as a non-trivial custom time zone example, and if you really
+// have to have Posix time zones, you're welcome to use this one.
+
+#include "date/tz.h"
+#include <cctype>
+#include <ostream>
+#include <string>
+
+namespace Posix
+{
+
+namespace detail
+{
+
+#if HAS_STRING_VIEW
+
+using string_t = std::string_view;
+
+#else  // !HAS_STRING_VIEW
+
+using string_t = std::string;
+
+#endif  // !HAS_STRING_VIEW
+
+class rule;
+
+void throw_invalid(const string_t& s, unsigned i, const string_t& message);
+unsigned read_date(const string_t& s, unsigned i, rule& r);
+unsigned read_name(const string_t& s, unsigned i, std::string& name);
+unsigned read_signed_time(const string_t& s, unsigned i, std::chrono::seconds& t);
+unsigned read_unsigned_time(const string_t& s, unsigned i, std::chrono::seconds& t);
+unsigned read_unsigned(const string_t& s, unsigned i,  unsigned limit, unsigned& u);
+
+class rule
+{
+    enum {off, J, M, N};
+
+    date::month m_;
+    date::weekday wd_;
+    unsigned short n_    : 14;
+    unsigned short mode_ : 2;
+    std::chrono::duration<std::int32_t> time_ = std::chrono::hours{2};
+
+public:
+    rule() : mode_(off) {}
+
+    bool ok() const {return mode_ != off;}
+    date::local_seconds operator()(date::year y) const;
+
+    friend std::ostream& operator<<(std::ostream& os, const rule& r);
+    friend unsigned read_date(const string_t& s, unsigned i, rule& r);
+};
+
+inline
+date::local_seconds
+rule::operator()(date::year y) const
+{
+    using date::local_days;
+    using date::January;
+    using date::days;
+    using date::last;
+    using sec = std::chrono::seconds;
+    date::local_seconds t;
+    switch (mode_)
+    {
+    case J:
+        t = local_days{y/January/0} + days{n_ + (y.is_leap() && n_ > 59)} + sec{time_};
+        break;
+    case M:
+        t = (n_ == 5 ? local_days{y/m_/wd_[last]} : local_days{y/m_/wd_[n_]}) + sec{time_};
+        break;
+    case N:
+        t = local_days{y/January/1} + days{n_} + sec{time_};
+        break;
+    default:
+        assert(!"rule called with bad mode");
+    }
+    return t;
+}
+
+inline
+std::ostream&
+operator<<(std::ostream& os, const rule& r)
+{
+    switch (r.mode_)
+    {
+    case rule::J:
+        os << 'J' << r.n_ << date::format(" %T", r.time_);
+        break;
+    case rule::M:
+        if (r.n_ == 5)
+            os << r.m_/r.wd_[date::last];
+        else
+            os << r.m_/r.wd_[r.n_];
+        os <<  date::format(" %T", r.time_);
+        break;
+    case rule::N:
+        os << r.n_ << date::format(" %T", r.time_);
+        break;
+    default:
+        break;
+    }
+    return os;
+}
+
+}  // namespace detail
+
+class time_zone
+{
+    std::string          std_abbrev_;
+    std::string          dst_abbrev_ = {};
+    std::chrono::seconds offset_;
+    std::chrono::seconds save_ = std::chrono::hours{1};
+    detail::rule         start_rule_;
+    detail::rule         end_rule_;
+
+public:
+    explicit time_zone(const detail::string_t& name);
+
+    template <class Duration>
+        date::sys_info   get_info(date::sys_time<Duration> st) const;
+    template <class Duration>
+        date::local_info get_info(date::local_time<Duration> tp) const;
+
+    template <class Duration>
+        date::sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
+        to_sys(date::local_time<Duration> tp) const;
+
+    template <class Duration>
+        date::sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
+        to_sys(date::local_time<Duration> tp, date::choose z) const;
+
+    template <class Duration>
+        date::local_time<typename std::common_type<Duration, std::chrono::seconds>::type>
+        to_local(date::sys_time<Duration> tp) const;
+
+    friend std::ostream& operator<<(std::ostream& os, const time_zone& z);
+
+    const time_zone* operator->() const {return this;}
+};
+
+inline
+time_zone::time_zone(const detail::string_t& s)
+{
+    using detail::read_name;
+    using detail::read_signed_time;
+    using detail::throw_invalid;
+    auto i = read_name(s, 0, std_abbrev_);
+    i = read_signed_time(s, i, offset_);
+    offset_ = -offset_;
+    if (i != s.size())
+    {
+        i = read_name(s, i, dst_abbrev_);
+        if (i != s.size())
+        {
+            if (s[i] != ',')
+                i = read_signed_time(s, i, save_);
+            if (i != s.size())
+            {
+                if (s[i] != ',')
+                    throw_invalid(s, i, "Expecting end of string or ',' to start rule");
+                ++i;
+                i = read_date(s, i, start_rule_);
+                if (i == s.size() || s[i] != ',')
+                    throw_invalid(s, i, "Expecting ',' and then the ending rule");
+                ++i;
+                i = read_date(s, i, end_rule_);
+                if (i != s.size())
+                    throw_invalid(s, i, "Found unexpected trailing characters");
+            }
+        }
+    }
+}
+
+template <class Duration>
+date::sys_info
+time_zone::get_info(date::sys_time<Duration> st) const
+{
+    using date::sys_info;
+    using date::year_month_day;
+    using date::sys_seconds;
+    using date::sys_days;
+    using date::floor;
+    using date::ceil;
+    using date::days;
+    using date::years;
+    using date::year;
+    using date::January;
+    using date::December;
+    using date::last;
+    using std::chrono::minutes;
+    sys_info r{};
+    r.offset = offset_;
+    if (start_rule_.ok())
+    {
+        auto y = year_month_day{floor<days>(st)}.year();
+        auto start = sys_seconds{(start_rule_(y) - offset_).time_since_epoch()};
+        auto end   = sys_seconds{(end_rule_(y) - (offset_ + save_)).time_since_epoch()};
+        if (start <= st && st < end)
+        {
+            r.begin = start;
+            r.end = end;
+            r.offset += save_;
+            r.save = ceil<minutes>(save_);
+            r.abbrev = dst_abbrev_;
+        }
+        else if (st < start)
+        {
+            r.begin = sys_seconds{(end_rule_(y-years{1}) -
+                                   (offset_ + save_)).time_since_epoch()};
+            r.end = start;
+            r.abbrev = std_abbrev_;
+        }
+        else  // st >= end
+        {
+            r.begin = end;
+            r.end = sys_seconds{(start_rule_(y+years{1}) - offset_).time_since_epoch()};
+            r.abbrev = std_abbrev_;
+        }
+    }
+    else  //  constant offset
+    {
+        r.begin = sys_days{year::min()/January/1};
+        r.end   = sys_days{year::max()/December/last};
+        r.abbrev = std_abbrev_;
+    }
+    return r;
+}
+
+template <class Duration>
+date::local_info
+time_zone::get_info(date::local_time<Duration> tp) const
+{
+    using date::local_info;
+    using date::year_month_day;
+    using date::days;
+    using date::sys_days;
+    using date::sys_seconds;
+    using date::years;
+    using date::year;
+    using date::ceil;
+    using date::January;
+    using date::December;
+    using date::last;
+    using std::chrono::seconds;
+    using std::chrono::minutes;
+    local_info r{};
+    using date::floor;
+    if (start_rule_.ok())
+    {
+        auto y = year_month_day{floor<days>(tp)}.year();
+        auto start = sys_seconds{(start_rule_(y) - offset_).time_since_epoch()};
+        auto end   = sys_seconds{(end_rule_(y) - (offset_ + save_)).time_since_epoch()};
+        auto utcs = sys_seconds{floor<seconds>(tp - offset_).time_since_epoch()};
+        auto utcd = sys_seconds{floor<seconds>(tp - (offset_ + save_)).time_since_epoch()};
+        if ((utcs < start) != (utcd < start))
+        {
+            r.first.begin = sys_seconds{(end_rule_(y-years{1}) -
+                                         (offset_ + save_)).time_since_epoch()};
+            r.first.end = start;
+            r.first.offset = offset_;
+            r.first.abbrev = std_abbrev_;
+            r.second.begin = start;
+            r.second.end = end;
+            r.second.abbrev = dst_abbrev_;
+            r.second.offset = offset_ + save_;
+            r.second.save = ceil<minutes>(save_);
+            r.result = save_ > seconds{0} ? local_info::nonexistent
+                                          : local_info::ambiguous;
+        }
+        else if ((utcs < end) != (utcd < end))
+        {
+            r.first.begin = start;
+            r.first.end = end;
+            r.first.offset = offset_ + save_;
+            r.first.save = ceil<minutes>(save_);
+            r.first.abbrev = dst_abbrev_;
+            r.second.begin = end;
+            r.second.end = sys_seconds{(start_rule_(y+years{1}) -
+                                        offset_).time_since_epoch()};
+            r.second.abbrev = std_abbrev_;
+            r.second.offset = offset_;
+            r.result = save_ > seconds{0} ? local_info::ambiguous
+                                          : local_info::nonexistent;
+        }
+        else if (utcs < start)
+        {
+            r.first.begin = sys_seconds{(end_rule_(y-years{1}) -
+                                   (offset_ + save_)).time_since_epoch()};
+            r.first.end = start;
+            r.first.offset = offset_;
+            r.first.abbrev = std_abbrev_;
+        }
+        else if (utcs < end)
+        {
+            r.first.begin = start;
+            r.first.end = end;
+            r.first.offset = offset_ + save_;
+            r.first.save = ceil<minutes>(save_);
+            r.first.abbrev = dst_abbrev_;
+        }
+        else
+        {
+            r.first.begin = end;
+            r.first.end = sys_seconds{(start_rule_(y+years{1}) -
+                                       offset_).time_since_epoch()};
+            r.first.abbrev = std_abbrev_;
+            r.first.offset = offset_;
+        }
+    }
+    else  //  constant offset
+    {
+        r.first.begin = sys_days{year::min()/January/1};
+        r.first.end   = sys_days{year::max()/December/last};
+        r.first.abbrev = std_abbrev_;
+        r.first.offset = offset_;
+    }
+    return r;
+}
+
+template <class Duration>
+date::sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
+time_zone::to_sys(date::local_time<Duration> tp) const
+{
+    using date::local_info;
+    using date::sys_time;
+    using date::ambiguous_local_time;
+    auto i = get_info(tp);
+    if (i.result == local_info::nonexistent)
+        throw nonexistent_local_time(tp, i);
+    else if (i.result == local_info::ambiguous)
+        throw ambiguous_local_time(tp, i);
+    return sys_time<Duration>{tp.time_since_epoch()} - i.first.offset;
+}
+
+template <class Duration>
+date::sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
+time_zone::to_sys(date::local_time<Duration> tp, date::choose z) const
+{
+    using date::local_info;
+    using date::sys_time;
+    using date::choose;
+    auto i = get_info(tp);
+    if (i.result == local_info::nonexistent)
+    {
+        return i.first.end;
+    }
+    else if (i.result == local_info::ambiguous)
+    {
+        if (z == choose::latest)
+            return sys_time<Duration>{tp.time_since_epoch()} - i.second.offset;
+    }
+    return sys_time<Duration>{tp.time_since_epoch()} - i.first.offset;
+}
+
+template <class Duration>
+date::local_time<typename std::common_type<Duration, std::chrono::seconds>::type>
+time_zone::to_local(date::sys_time<Duration> tp) const
+{
+    using date::local_time;
+    using std::chrono::seconds;
+    using LT = local_time<typename std::common_type<Duration, seconds>::type>;
+    auto i = get_info(tp);
+    return LT{(tp + i.offset).time_since_epoch()};
+}
+
+inline
+std::ostream&
+operator<<(std::ostream& os, const time_zone& z)
+{
+    using date::operator<<;
+    os << '{';
+    os << z.std_abbrev_ << ", " << z.dst_abbrev_ << date::format(", %T, ", z.offset_)
+       << date::format("%T, [", z.save_) << z.start_rule_ << ", " << z.end_rule_ << ")}";
+    return os;
+}
+
+namespace detail
+{
+
+inline
+void
+throw_invalid(const string_t& s, unsigned i, const string_t& message)
+{
+    throw std::runtime_error(std::string("Invalid time_zone initializer.\n") +
+                             std::string(message) + ":\n" +
+                             std::string(s) + '\n' +
+                             "\x1b[1;32m" +
+                             std::string(i, '~') + '^' +
+                             std::string(s.size()-i-1, '~') +
+                             "\x1b[0m");
+}
+
+inline
+unsigned
+read_date(const string_t& s, unsigned i, rule& r)
+{
+    using date::month;
+    using date::weekday;
+    if (i == s.size())
+        throw_invalid(s, i, "Expected rule but found end of string");
+    if (s[i] == 'J')
+    {
+        ++i;
+        unsigned n;
+        i = read_unsigned(s, i, 3, n);
+        r.mode_ = rule::J;
+        r.n_ = n;
+    }
+    else if (s[i] == 'M')
+    {
+        ++i;
+        unsigned m;
+        i = read_unsigned(s, i, 2, m);
+        if (i == s.size() || s[i] != '.')
+            throw_invalid(s, i, "Expected '.' after month");
+        ++i;
+        unsigned n;
+        i = read_unsigned(s, i, 1, n);
+        if (i == s.size() || s[i] != '.')
+            throw_invalid(s, i, "Expected '.' after weekday index");
+        ++i;
+        unsigned wd;
+        i = read_unsigned(s, i, 1, wd);
+        r.mode_ = rule::M;
+        r.m_ = month{m};
+        r.wd_ = weekday{wd};
+        r.n_ = n;
+    }
+    else if (std::isdigit(s[i]))
+    {
+        unsigned n;
+        i = read_unsigned(s, i, 3, n);
+        r.mode_ = rule::N;
+        r.n_ = n;
+    }
+    else
+        throw_invalid(s, i, "Expected 'J', 'M', or a digit to start rule");
+    if (i != s.size() && s[i] == '/')
+    {
+        ++i;
+        std::chrono::seconds t;
+        i = read_unsigned_time(s, i, t);
+        r.time_ = t;
+    }
+    return i;
+}
+
+inline
+unsigned
+read_name(const string_t& s, unsigned i, std::string& name)
+{
+    if (i == s.size())
+        throw_invalid(s, i, "Expected a name but found end of string");
+    if (s[i] == '<')
+    {
+        ++i;
+        while (true)
+        {
+            if (i == s.size())
+                throw_invalid(s, i,
+                              "Expected to find closing '>', but found end of string");
+            if (s[i] == '>')
+                break;
+            name.push_back(s[i]);
+            ++i;
+        }
+        ++i;
+    }
+    else
+    {
+        while (i != s.size() && std::isalpha(s[i]))
+        {
+            name.push_back(s[i]);
+            ++i;
+        }
+    }
+    if (name.size() < 3)
+        throw_invalid(s, i, "Found name to be shorter than 3 characters");
+    return i;
+}
+
+inline
+unsigned
+read_signed_time(const string_t& s, unsigned i,
+                                  std::chrono::seconds& t)
+{
+    if (i == s.size())
+        throw_invalid(s, i, "Expected to read signed time, but found end of string");
+    bool negative = false;
+    if (s[i] == '-')
+    {
+        negative = true;
+        ++i;
+    }
+    else if (s[i] == '+')
+        ++i;
+    i = read_unsigned_time(s, i, t);
+    if (negative)
+        t = -t;
+    return i;
+}
+
+inline
+unsigned
+read_unsigned_time(const string_t& s, unsigned i, std::chrono::seconds& t)
+{
+    using std::chrono::seconds;
+    using std::chrono::minutes;
+    using std::chrono::hours;
+    if (i == s.size())
+        throw_invalid(s, i, "Expected to read unsigned time, but found end of string");
+    unsigned x;
+    i = read_unsigned(s, i, 2, x);
+    t = hours{x};
+    if (i != s.size() && s[i] == ':')
+    {
+        ++i;
+        i = read_unsigned(s, i, 2, x);
+        t += minutes{x};
+        if (i != s.size() && s[i] == ':')
+        {
+            ++i;
+            i = read_unsigned(s, i, 2, x);
+            t += seconds{x};
+        }
+    }
+    return i;
+}
+
+inline
+unsigned
+read_unsigned(const string_t& s, unsigned i, unsigned limit, unsigned& u)
+{
+    if (i == s.size() || !std::isdigit(s[i]))
+        throw_invalid(s, i, "Expected to find a decimal digit");
+    u = static_cast<unsigned>(s[i] - '0');
+    unsigned count = 1;
+    for (++i; count < limit && i != s.size() && std::isdigit(s[i]); ++i, ++count)
+        u = u * 10 + static_cast<unsigned>(s[i] - '0');
+    return i;
+}
+
+}  // namespace detail
+
+}  // namespace Posix
+
+namespace date
+{
+
+template <>
+struct zoned_traits<Posix::time_zone>
+{
+
+#if HAS_STRING_VIEW
+
+    static
+    Posix::time_zone
+    locate_zone(std::string_view name)
+    {
+        return Posix::time_zone{name};
+    }
+
+#else  // !HAS_STRING_VIEW
+
+    static
+    Posix::time_zone
+    locate_zone(const std::string& name)
+    {
+        return Posix::time_zone{name};
+    }
+
+    static
+    Posix::time_zone
+    locate_zone(const char* name)
+    {
+        return Posix::time_zone{name};
+    }
+
+#endif  // !HAS_STRING_VIEW
+
+};
+
+}  // namespace date
+
+#endif  // PTZ_H

include/date/tz_private.h

@@ -2,19 +2,19 @@
 #define TZ_PRIVATE_H
 
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -22,12 +22,34 @@
 // 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.
+//
+// Our apologies.  When the previous paragraph was written, lowercase had not yet
+// been invented (that would involve another several millennia of evolution).
+// We did not mean to shout.
 
+#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
 #include "tz.h"
+#else
+#include "date.h"
+#include <vector>
+#endif
 
 namespace date
 {
 
+namespace detail
+{
+
+#if !USE_OS_TZDB
+
+enum class tz {utc, local, standard};
+
+//forward declare to avoid warnings in gcc 6.2
+class MonthDayTime;
+std::istream& operator>>(std::istream& is, MonthDayTime& x);
+std::ostream& operator<<(std::ostream& os, const MonthDayTime& x);
+
+
 class MonthDayTime
 {
 private:
@@ -61,9 +83,9 @@ private:
 #if !defined(_MSC_VER) || (_MSC_VER >= 1900)
         U() : month_day_{date::jan/1} {}
 #else
-        U() : 
-            month_day_(date::jan/1), 
-            month_weekday_last_(date::month(0U), date::weekday_last(date::weekday(0U))) 
+        U() :
+            month_day_(date::jan/1),
+            month_weekday_last_(date::month(0U), date::weekday_last(date::weekday(0U)))
         {}
 
 #endif // !defined(_MSC_VER) || (_MSC_VER >= 1900)
@@ -73,14 +95,14 @@ private:
         U& operator=(const pair& x);
     } u;
 
-    std::chrono::hours           h_{0};
-    std::chrono::minutes         m_{0};
-    std::chrono::seconds         s_{0};
+    std::chrono::hours           h_{};
+    std::chrono::minutes         m_{};
+    std::chrono::seconds         s_{};
     tz                           zone_{tz::local};
 
 public:
     MonthDayTime() = default;
-    MonthDayTime(second_point tp, tz timezone);
+    MonthDayTime(local_seconds tp, tz timezone);
     MonthDayTime(const date::month_day& md, tz timezone);
 
     date::day day() const;
@@ -89,11 +111,11 @@ public:
 
     void canonicalize(date::year y);
 
-    second_point
+    sys_seconds
        to_sys(date::year y, std::chrono::seconds offset, std::chrono::seconds save) const;
-    date::day_point to_day_point(date::year y) const;
+    sys_days to_sys_days(date::year y) const;
 
-    second_point to_time_point(date::year y) const;
+    sys_seconds to_time_point(date::year y) const;
     int compare(date::year y, const MonthDayTime& x, date::year yx,
                 std::chrono::seconds offset, std::chrono::minutes prev_save) const;
 
@@ -104,11 +126,25 @@ public:
 // A Rule specifies one or more set of datetimes without using an offset.
 // Multiple dates are specified with multiple years.  The years in effect
 // go from starting_year_ to ending_year_, inclusive.  starting_year_ <=
-// ending_year_. save_ is ineffect for times from the specified time
+// ending_year_. save_ is in effect for times from the specified time
 // onward, including the specified time. When the specified time is
 // local, it uses the save_ from the chronologically previous Rule, or if
 // there is none, 0.
 
+//forward declare to avoid warnings in gcc 6.2
+class Rule;
+bool operator==(const Rule& x, const Rule& y);
+bool operator<(const Rule& x, const Rule& y);
+bool operator==(const Rule& x, const date::year& y);
+bool operator<(const Rule& x, const date::year& y);
+bool operator==(const date::year& x, const Rule& y);
+bool operator<(const date::year& x, const Rule& y);
+bool operator==(const Rule& x, const std::string& y);
+bool operator<(const Rule& x, const std::string& y);
+bool operator==(const std::string& x, const Rule& y);
+bool operator<(const std::string& x, const Rule& y);
+std::ostream& operator<<(std::ostream& os, const Rule& r);
+
 class Rule
 {
 private:
@@ -181,7 +217,7 @@ inline bool operator> (const std::string& x, const Rule& y) {return   y < x;}
 inline bool operator<=(const std::string& x, const Rule& y) {return !(y < x);}
 inline bool operator>=(const std::string& x, const Rule& y) {return !(x < y);}
 
-struct Zone::zonelet
+struct zonelet
 {
     enum tag {has_rule, has_save, is_empty};
 
@@ -203,14 +239,14 @@ struct Zone::zonelet
         U& operator=(const U&) = delete;
     } u;
 
-    std::string          format_;
-    date::year           until_year_{0};
-    MonthDayTime         until_date_;
-    second_point         until_utc_;
-    second_point         until_std_;
-    second_point         until_loc_;
-    std::chrono::minutes initial_save_{};
-    std::string          initial_abbrev_;
+    std::string                        format_;
+    date::year                         until_year_{0};
+    MonthDayTime                       until_date_;
+    sys_seconds                        until_utc_;
+    local_seconds                      until_std_;
+    local_seconds                      until_loc_;
+    std::chrono::minutes               initial_save_{};
+    std::string                        initial_abbrev_;
     std::pair<const Rule*, date::year> first_rule_{nullptr, date::year::min()};
     std::pair<const Rule*, date::year> last_rule_{nullptr, date::year::max()};
 
@@ -220,6 +256,61 @@ struct Zone::zonelet
     zonelet& operator=(const zonelet&) = delete;
 };
 
+#else  // USE_OS_TZDB
+
+struct ttinfo
+{
+    std::int32_t  tt_gmtoff;
+    unsigned char tt_isdst;
+    unsigned char tt_abbrind;
+    unsigned char pad[2];
+};
+
+static_assert(sizeof(ttinfo) == 8, "");
+
+struct expanded_ttinfo
+{
+    std::chrono::seconds offset;
+    std::string          abbrev;
+    bool                 is_dst;
+};
+
+struct transition
+{
+    sys_seconds            timepoint;
+    const expanded_ttinfo* info;
+
+    transition(sys_seconds tp, const expanded_ttinfo* i = nullptr)
+        : timepoint(tp)
+        , info(i)
+        {}
+
+    friend
+    std::ostream&
+    operator<<(std::ostream& os, const transition& t)
+    {
+        using date::operator<<;
+        os << t.timepoint << "Z ";
+        if (t.info->offset >= std::chrono::seconds{0})
+            os << '+';
+        os << make_time(t.info->offset);
+        if (t.info->is_dst > 0)
+            os << " daylight ";
+        else
+            os << " standard ";
+        os << t.info->abbrev;
+        return os;
+    }
+};
+
+#endif  // USE_OS_TZDB
+
+}  // namespace detail
+
 }  // namespace date
 
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+#include "tz.h"
+#endif
+
 #endif  // TZ_PRIVATE_H

src/ios.mm

@@ -0,0 +1,337 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Alexander Kormanovsky
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+//
+
+#include "date/ios.h"
+
+#if TARGET_OS_IPHONE
+
+#include <Foundation/Foundation.h>
+
+#include <fstream>
+#include <zlib.h>
+#include <sys/stat.h>
+
+#ifndef TAR_DEBUG
+#  define TAR_DEBUG 0
+#endif
+
+#define INTERNAL_DIR        "Library"
+#define TZDATA_DIR          "tzdata"
+#define TARGZ_EXTENSION     "tar.gz"
+
+#define TAR_BLOCK_SIZE                  512
+#define TAR_TYPE_POSITION               156
+#define TAR_NAME_POSITION               0
+#define TAR_NAME_SIZE                   100
+#define TAR_SIZE_POSITION               124
+#define TAR_SIZE_SIZE                   12
+
+namespace date
+{
+    namespace iOSUtils
+    {
+        
+        struct TarInfo
+        {
+            char objType;
+            std::string objName;
+            size_t realContentSize; // writable size without padding zeroes
+            size_t blocksContentSize; // adjusted size to 512 bytes blocks
+            bool success;
+        };
+        
+        std::string convertCFStringRefPathToCStringPath(CFStringRef ref);
+        bool extractTzdata(CFURLRef homeUrl, CFURLRef archiveUrl, std::string destPath);
+        TarInfo getTarObjectInfo(std::ifstream &readStream);
+        std::string getTarObject(std::ifstream &readStream, int64_t size);
+        bool writeFile(const std::string &tzdataPath, const std::string &fileName,
+                       const std::string &data, size_t realContentSize);
+        
+        std::string
+        get_current_timezone()
+        {
+            CFTimeZoneRef tzRef = CFTimeZoneCopySystem();
+            CFStringRef tzNameRef = CFTimeZoneGetName(tzRef);
+            CFIndex bufferSize = CFStringGetLength(tzNameRef) + 1;
+            char buffer[bufferSize];
+            
+            if (CFStringGetCString(tzNameRef, buffer, bufferSize, kCFStringEncodingUTF8))
+            {
+                CFRelease(tzRef);
+                return std::string(buffer);
+            }
+            
+            CFRelease(tzRef);
+            
+            return "";
+        }
+        
+        std::string
+        get_tzdata_path()
+        {
+            CFURLRef homeUrlRef = CFCopyHomeDirectoryURL();
+            CFStringRef homePath = CFURLCopyPath(homeUrlRef);
+            std::string path(std::string(convertCFStringRefPathToCStringPath(homePath)) +
+                             INTERNAL_DIR + "/" + TZDATA_DIR);
+            std::string result_path(std::string(convertCFStringRefPathToCStringPath(homePath)) +
+                                    INTERNAL_DIR);
+            
+            if (access(path.c_str(), F_OK) == 0)
+            {
+#if TAR_DEBUG
+                printf("tzdata dir exists\n");
+#endif
+                CFRelease(homeUrlRef);
+                CFRelease(homePath);
+                
+                return result_path;
+            }
+            
+            CFBundleRef mainBundle = CFBundleGetMainBundle();
+            CFArrayRef paths = CFBundleCopyResourceURLsOfType(mainBundle, CFSTR(TARGZ_EXTENSION),
+                                                              NULL);
+            
+            if (CFArrayGetCount(paths) != 0)
+            {
+                // get archive path, assume there is no other tar.gz in bundle
+                CFURLRef archiveUrl = static_cast<CFURLRef>(CFArrayGetValueAtIndex(paths, 0));
+                CFStringRef archiveName = CFURLCopyPath(archiveUrl);
+                archiveUrl = CFBundleCopyResourceURL(mainBundle, archiveName, NULL, NULL);
+                
+                extractTzdata(homeUrlRef, archiveUrl, path);
+                
+                CFRelease(archiveUrl);
+                CFRelease(archiveName);
+            }
+            
+            CFRelease(homeUrlRef);
+            CFRelease(homePath);
+            CFRelease(paths);
+            
+            return result_path;
+        }
+        
+        std::string
+        convertCFStringRefPathToCStringPath(CFStringRef ref)
+        {
+            CFIndex bufferSize = CFStringGetMaximumSizeOfFileSystemRepresentation(ref);
+            char *buffer = new char[bufferSize];
+            CFStringGetFileSystemRepresentation(ref, buffer, bufferSize);
+            auto result = std::string(buffer);
+            delete[] buffer;
+            return result;
+        }
+        
+        bool
+        extractTzdata(CFURLRef homeUrl, CFURLRef archiveUrl, std::string destPath)
+        {
+            std::string TAR_TMP_PATH = "/tmp.tar";
+            
+            CFStringRef homeStringRef = CFURLCopyPath(homeUrl);
+            auto homePath = convertCFStringRefPathToCStringPath(homeStringRef);
+            CFRelease(homeStringRef);
+            
+            CFStringRef archiveStringRef = CFURLCopyPath(archiveUrl);
+            auto archivePath = convertCFStringRefPathToCStringPath(archiveStringRef);
+            CFRelease(archiveStringRef);
+            
+            // create Library path
+            auto libraryPath = homePath + INTERNAL_DIR;
+            
+            // create tzdata path
+            auto tzdataPath = libraryPath + "/" + TZDATA_DIR;
+            
+            // -- replace %20 with " "
+            const std::string search = "%20";
+            const std::string replacement = " ";
+            size_t pos = 0;
+            
+            while ((pos = archivePath.find(search, pos)) != std::string::npos) {
+                archivePath.replace(pos, search.length(), replacement);
+                pos += replacement.length();
+            }
+            
+            gzFile tarFile = gzopen(archivePath.c_str(), "rb");
+            
+            // create tar unpacking path
+            auto tarPath = libraryPath + TAR_TMP_PATH;
+            
+            // create tzdata directory
+            mkdir(destPath.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+            
+            // ======= extract tar ========
+            
+            std::ofstream os(tarPath.c_str(), std::ofstream::out | std::ofstream::app);
+            unsigned int bufferLength = 1024 * 256;  // 256Kb
+            unsigned char *buffer = (unsigned char *)malloc(bufferLength);
+            bool success = true;
+            
+            while (true)
+            {
+                int readBytes = gzread(tarFile, buffer, bufferLength);
+                
+                if (readBytes > 0)
+                {
+                    os.write((char *) &buffer[0], readBytes);
+                }
+                else
+                    if (readBytes == 0)
+                    {
+                        break;
+                    }
+                    else
+                        if (readBytes == -1)
+                        {
+                            printf("decompression failed\n");
+                            success = false;
+                            break;
+                        }
+                        else
+                        {
+                            printf("unexpected zlib state\n");
+                            success = false;
+                            break;
+                        }
+            }
+            
+            os.close();
+            free(buffer);
+            gzclose(tarFile);
+            
+            if (!success)
+            {
+                remove(tarPath.c_str());
+                return false;
+            }
+            
+            // ======== extract files =========
+            
+            uint64_t location = 0; // Position in the file
+            
+            // get file size
+            struct stat stat_buf;
+            int res = stat(tarPath.c_str(), &stat_buf);
+            if (res != 0)
+            {
+                printf("error file size\n");
+                remove(tarPath.c_str());
+                return false;
+            }
+            int64_t tarSize = stat_buf.st_size;
+            
+            // create read stream
+            std::ifstream is(tarPath.c_str(), std::ifstream::in | std::ifstream::binary);
+            
+            // process files
+            while (location < tarSize)
+            {
+                TarInfo info = getTarObjectInfo(is);
+                
+                if (!info.success || info.realContentSize == 0)
+                {
+                    break; // something wrong or all files are read
+                }
+                
+                switch (info.objType)
+                {
+                    case '0':   // file
+                    case '\0':  //
+                    {
+                        std::string obj = getTarObject(is, info.blocksContentSize);
+#if TAR_DEBUG
+                        size += info.realContentSize;
+                        printf("#%i %s file size %lld written total %ld from %lld\n", ++count,
+                               info.objName.c_str(), info.realContentSize, size, tarSize);
+#endif
+                        writeFile(tzdataPath, info.objName, obj, info.realContentSize);
+                        location += info.blocksContentSize;
+                        
+                        break;
+                    }
+                }
+            }
+            
+            remove(tarPath.c_str());
+            
+            return true;
+        }
+        
+        TarInfo
+        getTarObjectInfo(std::ifstream &readStream)
+        {
+            int64_t length = TAR_BLOCK_SIZE;
+            char buffer[length];
+            char type;
+            char name[TAR_NAME_SIZE + 1];
+            char sizeBuf[TAR_SIZE_SIZE + 1];
+            
+            readStream.read(buffer, length);
+            
+            memcpy(&type, &buffer[TAR_TYPE_POSITION], 1);
+            
+            memset(&name, '\0', TAR_NAME_SIZE + 1);
+            memcpy(&name, &buffer[TAR_NAME_POSITION], TAR_NAME_SIZE);
+            
+            memset(&sizeBuf, '\0', TAR_SIZE_SIZE + 1);
+            memcpy(&sizeBuf, &buffer[TAR_SIZE_POSITION], TAR_SIZE_SIZE);
+            size_t realSize = strtol(sizeBuf, NULL, 8);
+            size_t blocksSize = realSize + (TAR_BLOCK_SIZE - (realSize % TAR_BLOCK_SIZE));
+            
+            return {type, std::string(name), realSize, blocksSize, true};
+        }
+        
+        std::string
+        getTarObject(std::ifstream &readStream, int64_t size)
+        {
+            char buffer[size];
+            readStream.read(buffer, size);
+            return std::string(buffer);
+        }
+        
+        bool
+        writeFile(const std::string &tzdataPath, const std::string &fileName, const std::string &data,
+                  size_t realContentSize)
+        {
+            std::ofstream os(tzdataPath + "/" + fileName, std::ofstream::out | std::ofstream::binary);
+            
+            if (!os) {
+                return false;
+            }
+            
+            // trim empty space
+            char trimmedData[realContentSize + 1];
+            memset(&trimmedData, '\0', realContentSize);
+            memcpy(&trimmedData, data.c_str(), realContentSize);
+            
+            // write
+            os.write(trimmedData, realContentSize);
+            os.close();
+            
+            return true;
+        }
+        
+    }  // namespace iOSUtils
+}  // namespace date
+
+#endif  // TARGET_OS_IPHONE

test/clock_cast_test/constexpr.pass.cpp

@@ -0,0 +1,75 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 nanoric
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "tz.h"
+#include <cassert>
+#include <type_traits>
+
+struct const_clock {
+  using duration =
+      typename std::common_type<std::chrono::system_clock::duration,
+          date::days>::type;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<const_clock, duration>;
+
+  static constexpr date::sys_days epoch { date::days { 1000 } };
+
+  template <typename Duration>
+  static std::chrono::time_point<std::chrono::system_clock,
+      typename std::common_type<Duration, date::days>::type>
+      CONSTCD11 to_sys(std::chrono::time_point<const_clock, Duration> const& tp)
+  {
+    return epoch + tp.time_since_epoch();
+  }
+
+  template <typename Duration>
+  static std::chrono::time_point<const_clock,
+      typename std::common_type<Duration, date::days>::type>
+      CONSTCD11 from_sys(
+          std::chrono::time_point<std::chrono::system_clock, Duration> const&
+              tp)
+  {
+    using res = std::chrono::time_point<const_clock,
+        typename std::common_type<Duration, date::days>::type>;
+    return res(tp - epoch);
+  }
+};
+
+int main()
+{
+  using namespace date;
+  using namespace std::chrono;
+  using const_days = time_point<const_clock, days>;
+
+  CONSTCD14 sys_days sys { days { 1024 } };
+  static_assert(sys.time_since_epoch().count() == 1024, "");
+
+  CONSTCD14 const_days c {clock_cast<const_clock>(sys)};
+  CONSTCD14 sys_days sys2 {clock_cast<system_clock>(c)};
+  CONSTCD14 sys_days sys3 { clock_cast<system_clock>(const_days(days(48))) };
+#if __cplusplus >= 201402L
+  static_assert(c.time_since_epoch().count() == 24, "");
+  static_assert(sys2.time_since_epoch().count() == 1024, "");
+  static_assert(sys3.time_since_epoch().count() == 1048, "");
+#endif
+}

test/clock_cast_test/custom_clock.pass.cpp

@@ -0,0 +1,213 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017, 2018 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "tz.h"
+#include <cassert>
+#include <type_traits>
+
+//used to count number of conversion
+int conversions = 0;
+
+//to/from impl
+struct mil_clock
+{
+  using duration = typename std::common_type<std::chrono::system_clock::duration, date::days>::type;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<mil_clock, duration>;
+
+  static constexpr date::sys_days epoch{date::days{1000}};
+
+  template<typename Duration>
+  static
+  std::chrono::time_point<std::chrono::system_clock, typename std::common_type<Duration, date::days>::type>
+  to_sys(std::chrono::time_point<mil_clock, Duration> const& tp)
+  {
+    ++conversions;
+    return epoch + tp.time_since_epoch();
+  }
+
+  template<typename Duration>
+  static
+  std::chrono::time_point<mil_clock, typename std::common_type<Duration, date::days>::type>
+  from_sys(std::chrono::time_point<std::chrono::system_clock, Duration> const& tp)
+  {
+    ++conversions;
+    using res = std::chrono::time_point<mil_clock, typename std::common_type<Duration, date::days>::type>;
+    return res(tp - epoch);
+  }
+
+  template<typename Duration>
+  static
+  std::chrono::time_point<date::local_t, typename std::common_type<Duration, date::days>::type>
+  to_local(std::chrono::time_point<mil_clock, Duration> const& tp)
+  {
+     return date::clock_cast<date::local_t>(to_sys(tp));
+  }
+
+  template<typename Duration>
+  static
+  std::chrono::time_point<mil_clock, typename std::common_type<Duration, date::days>::type>
+  from_local(std::chrono::time_point<date::local_t, Duration> const& tp)
+  {
+    return from_sys(date::clock_cast<std::chrono::system_clock>(tp));
+  }
+
+
+  static time_point now()
+  {
+    return from_sys(std::chrono::system_clock::now());
+  }
+};
+
+
+date::sys_days const mil_clock::epoch;
+
+// traits example
+struct s2s_clock
+{
+  using duration = std::chrono::system_clock::duration;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<s2s_clock, duration>;
+
+  template<typename Duration>
+  static
+  std::chrono::time_point<std::chrono::system_clock, Duration>
+  to_sys(std::chrono::time_point<s2s_clock, Duration> const& tp)
+  {
+    ++conversions;
+    return std::chrono::time_point<std::chrono::system_clock, Duration>(tp.time_since_epoch());
+  }
+
+  template<typename Duration>
+  static
+  std::chrono::time_point<s2s_clock, Duration>
+  from_sys(std::chrono::time_point<std::chrono::system_clock, Duration> const& tp)
+  {
+    ++conversions;
+    return std::chrono::time_point<s2s_clock, Duration>(tp.time_since_epoch());
+  }
+
+  static time_point now()
+  {
+    return from_sys(std::chrono::system_clock::now());
+  }
+};
+
+namespace date
+{
+   template<>
+   struct clock_time_conversion<mil_clock, s2s_clock>
+   {
+     template<typename Duration>
+     std::chrono::time_point<mil_clock, typename std::common_type<Duration, date::days>::type>
+     operator()(std::chrono::time_point<s2s_clock, Duration> const& tp)
+     {
+       ++conversions;
+       using res = std::chrono::time_point<mil_clock, typename std::common_type<Duration, date::days>::type>;
+       return res(tp.time_since_epoch() - mil_clock::epoch.time_since_epoch());
+     }
+   };
+}
+
+int
+main()
+{
+    using namespace date;
+    using sys_clock = std::chrono::system_clock;
+
+    // self
+    {
+       sys_days st(1997_y/dec/12);
+       auto mt = mil_clock::from_sys(st);
+
+       assert(clock_cast<mil_clock>(mt) == mt);
+    }
+
+    // mil <-> local
+    {
+       local_days lt(1997_y/dec/12);
+       auto mt = mil_clock::from_local(lt);
+
+       assert(clock_cast<mil_clock>(lt) == mt);
+       assert(clock_cast<local_t>(mt) == lt);
+    }
+
+    // mil <-> sys
+    {
+       sys_days st(1997_y/dec/12);
+       auto mt = mil_clock::from_sys(st);
+
+       assert(clock_cast<mil_clock>(st) == mt);
+       assert(clock_cast<sys_clock>(mt) == st);
+    }
+
+    // mil <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto mt = mil_clock::from_sys(st);
+       auto ut = utc_clock::from_sys(st);
+
+       assert(clock_cast<mil_clock>(ut) == mt);
+       assert(clock_cast<utc_clock>(mt) == ut);
+    }
+
+    // mil <-> tai
+    {
+       sys_days st(1997_y/dec/12);
+       auto mt = mil_clock::from_sys(st);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+
+       assert(clock_cast<tai_clock>(mt) == tt);
+       assert(clock_cast<mil_clock>(tt) == mt);
+    }
+
+    // mil <-> gps
+    {
+       sys_days st(1997_y/dec/12);
+       auto mt = mil_clock::from_sys(st);
+       auto ut = utc_clock::from_sys(st);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(clock_cast<gps_clock>(mt) == gt);
+       assert(clock_cast<mil_clock>(gt) == mt);
+    }
+
+    // s2s -> mil
+    {
+       sys_days st(1997_y/dec/12);
+       auto mt = mil_clock::from_sys(st);
+       auto s2t = s2s_clock::from_sys(st);
+
+       //direct trait conversion
+       conversions = 0;
+       assert(clock_cast<mil_clock>(s2t) == mt);
+       assert(conversions == 1);
+
+       //uses sys_clock
+       conversions = 0;
+       assert(clock_cast<s2s_clock>(mt) == s2t);
+       assert(conversions == 2);
+    }
+}

test/clock_cast_test/deprecated.pass.cpp

@@ -0,0 +1,90 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "tz.h"
+#include <cassert>
+
+int
+main()
+{
+    using namespace date;
+
+    // sys <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+
+       assert(to_utc_time(st) == ut);
+       assert(to_sys_time(ut) == st);
+    }
+
+    // tai <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+
+       assert(to_tai_time(ut) == tt);
+       assert(to_utc_time(tt) == ut);
+    }
+
+    // tai <-> sys
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+
+       assert(to_tai_time(st) == tt);
+       assert(to_sys_time(tt) == st);
+    }
+
+    // gps <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(to_gps_time(ut) == gt);
+       assert(to_utc_time(gt) == ut);
+    }
+
+    // gps <-> sys
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(to_gps_time(st) == gt);
+       assert(to_sys_time(gt) == st);
+    }
+
+    // tai <-> gps
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(to_gps_time(tt) == gt);
+       assert(to_tai_time(gt) == tt);
+    }
+}

test/clock_cast_test/local_t.pass.cpp

@@ -0,0 +1,132 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include <chrono>
+#include "date/tz.h"
+
+int
+main()
+{
+   using namespace date;
+   using namespace std::chrono;
+
+   // self
+   {
+     auto ls = local_days{1970_y/January/1_d};
+     assert(clock_cast<local_t>(ls) == ls);
+   }
+
+   /// sys epoch
+   {
+     auto ls = local_days{1970_y/January/1_d};
+     auto st = clock_cast<system_clock>(ls);
+     assert(clock_cast<local_t>(st) == ls);
+     assert(st.time_since_epoch() == seconds(0));
+   }
+
+   /// sys 2000 case
+   {
+     auto ls = local_days{2000_y/January/1_d};
+     auto st = clock_cast<system_clock>(ls);
+     assert(clock_cast<local_t>(st) == ls);
+     assert(st.time_since_epoch() == seconds(946684800));
+   }
+
+   /// utc epoch
+   {
+     auto lu = local_days{1970_y/January/1_d};
+     auto ut = clock_cast<utc_clock>(lu);
+     assert(clock_cast<local_t>(ut) == lu);
+     assert(ut.time_since_epoch() == seconds(0));
+   }
+
+   // utc leap second
+   {
+     auto lu = local_days{2015_y/July/1_d} - milliseconds(1);
+     auto ut = clock_cast<utc_clock>(lu) + milliseconds(50); //into leap second
+
+     assert(clock_cast<local_t>(ut) == lu);
+   }
+
+   /// utc paper example
+   {
+     auto lu = local_days{2000_y/January/1_d};
+     auto ut = clock_cast<utc_clock>(lu);
+     assert(clock_cast<local_t>(ut) == lu);
+     assert(ut.time_since_epoch() == seconds(946684822));
+   }
+
+   /// tai epoch
+   {
+     auto lt = local_days{1958_y/January/1_d};
+     auto tt = clock_cast<tai_clock>(lt);
+     assert(clock_cast<local_t>(tt) == lt);
+     assert(tt.time_since_epoch() == seconds(0));
+
+     auto lu = local_days{1958_y/January/1_d} - seconds(10);
+     auto ut = clock_cast<utc_clock>(lu);
+     assert(clock_cast<tai_clock>(ut) == tt);
+   }
+
+   // tai paper example
+   {
+      auto lt = local_days{2000_y/January/1_d} + seconds(32);
+      auto tt = clock_cast<tai_clock>(lt);
+      assert(clock_cast<local_t>(tt) == lt);
+
+      auto lu = local_days{2000_y/January/1_d};
+      auto ut = clock_cast<utc_clock>(lu);
+      assert(clock_cast<tai_clock>(ut) == tt);
+   }
+
+   /// gps epoch
+   {
+     auto lg = local_days{1980_y/January/Sunday[1]};
+     auto gt = clock_cast<gps_clock>(lg);
+     assert(clock_cast<local_t>(gt) == lg);
+     assert(gt.time_since_epoch() == seconds(0));
+
+     auto lu = local_days{1980_y/January/Sunday[1]};
+     auto ut = clock_cast<utc_clock>(lu);
+     assert(clock_cast<gps_clock>(ut) == gt);
+
+     auto lt = local_days{1980_y/January/Sunday[1]} + seconds(19);
+     auto tt = clock_cast<tai_clock>(lt);
+     assert(clock_cast<gps_clock>(tt) == gt);
+   }
+
+   // gps 2000 example
+   {
+     auto lg = local_days{2000_y/January/1_d};
+     auto gt = clock_cast<gps_clock>(lg);
+     assert(clock_cast<local_t>(gt) == lg);
+
+     auto lu = local_days{2000_y/January/1_d} - seconds(13);
+     auto ut = clock_cast<utc_clock>(lu);
+     assert(clock_cast<gps_clock>(ut) == gt);
+
+     auto lt = local_days{2000_y/January/1_d} + seconds(19);
+     auto tt = clock_cast<tai_clock>(lt);
+     assert(clock_cast<gps_clock>(tt) == gt);
+   }
+
+}

test/clock_cast_test/noncastable.pass.cpp

@@ -0,0 +1,251 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017, 2018 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "tz.h"
+#include <type_traits>
+#include <cassert>
+
+template<typename SourceClock, typename DestClock, typename = void>
+struct is_clock_castable
+  : std::false_type
+{};
+
+template<typename SourceClock, typename DestClock>
+struct is_clock_castable<SourceClock, DestClock, decltype(date::clock_cast<DestClock>(typename SourceClock::time_point()), void())>
+  : std::true_type
+{};
+
+
+//Clock based on steady clock, not related to wall time (sys_clock/utc_clock)
+struct steady_based_clock
+{
+  using duration = std::chrono::steady_clock::duration;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<steady_based_clock, duration>;
+
+  static time_point now()
+  {
+    return time_point(std::chrono::steady_clock::now().time_since_epoch());
+  }
+};
+
+//Traits that allow conversion between steady_clock and steady_based clock
+//Does not use wall-time clocks as rally (sys/utc)
+namespace date
+{
+   template<>
+   struct clock_time_conversion<std::chrono::steady_clock, steady_based_clock>
+   {
+     template<typename Duration>
+     std::chrono::time_point<std::chrono::steady_clock, Duration>
+     operator()(std::chrono::time_point<steady_based_clock, Duration> const& tp) const
+     {
+       using res = std::chrono::time_point<std::chrono::steady_clock, Duration>;
+       return res(tp.time_since_epoch());
+     }
+   };
+
+   template<>
+   struct clock_time_conversion<steady_based_clock, std::chrono::steady_clock>
+   {
+     template<typename Duration>
+     std::chrono::time_point<steady_based_clock, Duration>
+     operator()(std::chrono::time_point<std::chrono::steady_clock, Duration> const& tp) const
+     {
+       using res = std::chrono::time_point<steady_based_clock, Duration>;
+       return res(tp.time_since_epoch());
+     }
+   };
+}
+
+//Ambigous clocks both providing to/from_sys and to/from_utc
+//They are mock_ups just returning zero time_point
+struct amb1_clock
+{
+   using duration = std::chrono::seconds;
+   using rep = duration::rep;
+   using period = duration::period;
+   using time_point = std::chrono::time_point<amb1_clock>;
+
+   static time_point now()
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<std::chrono::system_clock, Duration>
+   to_sys(std::chrono::time_point<amb1_clock, Duration> const&)
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<amb1_clock, Duration>
+   from_sys(std::chrono::time_point<std::chrono::system_clock, Duration> const&)
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<date::utc_clock, Duration>
+   to_utc(std::chrono::time_point<amb1_clock, Duration> const&)
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<amb1_clock, Duration>
+   from_utc(std::chrono::time_point<date::utc_clock, Duration> const&)
+   {
+     return {};
+   }
+};
+
+struct amb2_clock
+{
+   using duration = std::chrono::seconds;
+   using rep = duration::rep;
+   using period = duration::period;
+   using time_point = std::chrono::time_point<amb2_clock>;
+
+   static time_point now()
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<std::chrono::system_clock, Duration>
+   to_sys(std::chrono::time_point<amb2_clock, Duration> const&)
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<amb2_clock, Duration>
+   from_sys(std::chrono::time_point<std::chrono::system_clock, Duration> const&)
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<date::utc_clock, Duration>
+   to_utc(std::chrono::time_point<amb2_clock, Duration> const&)
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<amb2_clock, Duration>
+   from_utc(std::chrono::time_point<date::utc_clock, Duration> const&)
+   {
+     return {};
+   }
+};
+
+namespace date
+{
+   //Disambiguates that sys_clock is preffered
+   template<>
+   struct clock_time_conversion<amb1_clock, amb2_clock>
+   {
+     template<typename Duration>
+     std::chrono::time_point<amb1_clock, Duration>
+     operator()(std::chrono::time_point<amb2_clock, Duration> const& tp) const
+     {
+       return amb1_clock::from_sys(amb2_clock::to_sys(tp));
+     }
+   };
+}
+
+int
+main()
+{
+    using namespace date;
+    using namespace std::chrono;
+    using sys_clock = std::chrono::system_clock;
+
+    //steady_clock (must be different that sys_clock)
+    static_assert(is_clock_castable<steady_clock, steady_clock>::value, "steady_clock -> steady_clock");
+    static_assert(!is_clock_castable<steady_clock, local_t>::value, "steady_clock -> local_t");
+    static_assert(!is_clock_castable<local_t, steady_clock>::value, "local_t -> steady_clock");
+    static_assert(!is_clock_castable<steady_clock, sys_clock>::value, "steady_clock -> sys_clock");
+    static_assert(!is_clock_castable<sys_clock, steady_clock>::value, "sys_clock -> steady_clock");
+    static_assert(!is_clock_castable<steady_clock, utc_clock>::value, "steady_clock -> utc_clock");
+    static_assert(!is_clock_castable<utc_clock, steady_clock>::value, "utc_clock -> steady_clock");
+    static_assert(!is_clock_castable<steady_clock, tai_clock>::value, "steady_clock -> tai_clock");
+    static_assert(!is_clock_castable<tai_clock, steady_clock>::value, "tai_clock -> steady_clock");
+
+    //steady_based_clock (unrelated to sys_clock and utc_clocks)
+    static_assert(is_clock_castable<steady_based_clock, steady_based_clock>::value, "steady_based_clock -> steady_based_clock");
+    static_assert(!is_clock_castable<steady_based_clock, local_t>::value, "steady_based_clock -> local_t");
+    static_assert(!is_clock_castable<local_t, steady_based_clock>::value, "local_t -> steady_based_clock");
+    static_assert(!is_clock_castable<steady_based_clock, sys_clock>::value, "steady_based_clock -> sys_clock");
+    static_assert(!is_clock_castable<sys_clock, steady_based_clock>::value, "sys_clock -> steady_based_clock");
+    static_assert(!is_clock_castable<steady_based_clock, utc_clock>::value, "steady_based_clock -> utc_clock");
+    static_assert(!is_clock_castable<utc_clock, steady_based_clock>::value, "utc_clock -> steady_based_clock");
+    static_assert(!is_clock_castable<steady_based_clock, tai_clock>::value, "steady_based_clock -> tai_clock");
+    static_assert(!is_clock_castable<tai_clock, steady_based_clock>::value, "tai_clock -> steady_based_clock");
+
+    //steady_based <-> steady_clock
+    {
+      auto s1 = steady_clock::time_point(steady_clock::duration(200));
+      auto s2 = steady_based_clock::time_point(steady_based_clock::duration(200));
+
+      assert(clock_cast<steady_based_clock>(s1) == s2);
+      assert(clock_cast<steady_clock>(s2) == s1);
+    }
+
+    //ambX <-> sys/utc works as one rally can be used in each case, or one lead to quicker conversione
+    static_assert(is_clock_castable<amb1_clock, amb1_clock>::value, "amb1_clock -> amb1_clock");
+    static_assert(is_clock_castable<amb1_clock, sys_clock>::value, "amb1_clock -> sys_clock");
+    static_assert(is_clock_castable<sys_clock, amb1_clock>::value, "sys_clock -> amb1_clock");
+    static_assert(is_clock_castable<amb1_clock, utc_clock>::value, "amb1_clock -> utc_clock");
+    static_assert(is_clock_castable<utc_clock, amb1_clock>::value, "utc_clock -> amb1_clock");
+    static_assert(is_clock_castable<amb1_clock, tai_clock>::value, "amb1_clock -> tai_clock");
+    static_assert(is_clock_castable<tai_clock, amb1_clock>::value, "tai_clock -> amb1_clock");
+    static_assert(is_clock_castable<amb1_clock, tai_clock>::value, "amb1_clock -> tai_clock");
+    static_assert(is_clock_castable<gps_clock, amb1_clock>::value, "gps_clock -> amb1_clock");
+    static_assert(is_clock_castable<amb2_clock, amb2_clock>::value, "amb2_clock -> amb2_clock");
+    static_assert(is_clock_castable<amb2_clock, sys_clock>::value, "amb2_clock -> sys_clock");
+    static_assert(is_clock_castable<sys_clock, amb2_clock>::value, "sys_clock -> amb2_clock");
+    static_assert(is_clock_castable<amb2_clock, utc_clock>::value, "amb2_clock -> utc_clock");
+    static_assert(is_clock_castable<utc_clock, amb2_clock>::value, "utc_clock -> amb2_clock");
+    static_assert(is_clock_castable<amb2_clock, tai_clock>::value, "amb2_clock -> tai_clock");
+    static_assert(is_clock_castable<tai_clock, amb2_clock>::value, "tai_clock -> amb2_clock");
+    static_assert(is_clock_castable<amb2_clock, tai_clock>::value, "amb2_clock -> tai_clock");
+    static_assert(is_clock_castable<gps_clock, amb2_clock>::value, "gps_clock -> amb2_clock");
+
+    //amb1 -> amb2: ambigous because can either go trough sys_clock or utc_clock
+    static_assert(!is_clock_castable<amb1_clock, amb2_clock>::value, "amb1_clock -> amb2_clock");
+
+    //amb2 -> amb1: disambiguated via trait specialization
+    static_assert(is_clock_castable<amb2_clock, amb1_clock>::value, "amb2_clock -> amb1_clock");
+}

test/clock_cast_test/normal_clocks.pass.cpp

@@ -0,0 +1,102 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "tz.h"
+#include <cassert>
+
+int
+main()
+{
+    using namespace date;
+    using sys_clock = std::chrono::system_clock;
+
+    // self
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+
+       assert(clock_cast<sys_clock>(st) == st);
+       assert(clock_cast<utc_clock>(ut) == ut);
+       assert(clock_cast<tai_clock>(tt) == tt);
+    }
+
+    // sys <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+
+       assert(clock_cast<utc_clock>(st) == ut);
+       assert(clock_cast<sys_clock>(ut) == st);
+    }
+
+    // tai <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+
+       assert(clock_cast<tai_clock>(ut) == tt);
+       assert(clock_cast<utc_clock>(tt) == ut);
+    }
+
+    // tai <-> sys
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+
+       assert(clock_cast<tai_clock>(st) == tt);
+       assert(clock_cast<sys_clock>(tt) == st);
+    }
+
+    // gps <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(clock_cast<gps_clock>(ut) == gt);
+       assert(clock_cast<utc_clock>(gt) == ut);
+    }
+
+    // gps <-> sys
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(clock_cast<gps_clock>(st) == gt);
+       assert(clock_cast<sys_clock>(gt) == st);
+    }
+
+    // tai <-> gps
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(clock_cast<gps_clock>(tt) == gt);
+       assert(clock_cast<tai_clock>(gt) == tt);
+    }
+}

test/clock_cast_test/to_sys_return_int.fail.cpp

@@ -0,0 +1,49 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "tz.h"
+
+struct bad_clock
+{
+  using duration = std::chrono::system_clock::duration;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<bad_clock, duration>;
+
+  template<typename Duration>
+  static
+  int
+  to_sys(std::chrono::time_point<bad_clock, Duration> const& tp)
+  {
+    return tp.time_since_epoch().count();
+  }
+};
+
+int
+main()
+{
+    using namespace date;
+    using sys_clock = std::chrono::system_clock;
+
+    auto bt = bad_clock::time_point();
+    clock_cast<sys_clock>(bt);
+}

test/clock_cast_test/to_sys_return_reference.fail.cpp

@@ -0,0 +1,51 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "tz.h"
+
+struct bad_clock
+{
+  using duration = std::chrono::system_clock::duration;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<bad_clock, duration>;
+
+  template<typename Duration>
+  static
+  date::sys_time<Duration> const&
+  to_sys(std::chrono::time_point<bad_clock, Duration> const& tp)
+  {
+    static date::sys_time<Duration> val;
+    val = date::sys_time<Duration>(tp.time_since_epoch());
+    return val;
+  }
+};
+
+int
+main()
+{
+    using namespace date;
+    using sys_clock = std::chrono::system_clock;
+
+    auto bt = bad_clock::time_point();
+    clock_cast<sys_clock>(bt);
+}

test/clock_cast_test/to_sys_return_utc_time.fail.cpp

@@ -0,0 +1,49 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017, 2018 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "tz.h"
+
+struct bad_clock
+{
+  using duration = std::chrono::system_clock::duration;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<bad_clock, duration>;
+
+  template<typename Duration>
+  static
+  date::utc_time<Duration>
+  to_sys(std::chrono::time_point<bad_clock, Duration> const& tp)
+  {
+    return date::utc_time<Duration>(tp.time_since_epoch());
+  }
+};
+
+int
+main()
+{
+    using namespace date;
+    using sys_clock = std::chrono::system_clock;
+
+    auto bt = bad_clock::time_point();
+    clock_cast<sys_clock>(bt);
+}

test/date_test/day.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -25,31 +25,31 @@
 //     unsigned char d_;
 // public:
 //     explicit constexpr day(unsigned d) noexcept;
-// 
+//
 //     day& operator++()    noexcept;
 //     day  operator++(int) noexcept;
 //     day& operator--()    noexcept;
 //     day  operator--(int) noexcept;
-// 
+//
 //     day& operator+=(const days& d) noexcept;
 //     day& operator-=(const days& d) noexcept;
-// 
+//
 //     constexpr explicit operator unsigned() const noexcept;
 //     constexpr bool ok() const noexcept;
 // };
-// 
+//
 // constexpr bool operator==(const day& x, const day& y) noexcept;
 // constexpr bool operator!=(const day& x, const day& y) noexcept;
 // constexpr bool operator< (const day& x, const day& y) noexcept;
 // constexpr bool operator> (const day& x, const day& y) noexcept;
 // constexpr bool operator<=(const day& x, const day& y) noexcept;
 // constexpr bool operator>=(const day& x, const day& y) noexcept;
-// 
+//
 // constexpr day  operator+(const day&  x, const days& y) noexcept;
 // constexpr day  operator+(const days& x, const day&  y) noexcept;
 // constexpr day  operator-(const day&  x, const days& y) noexcept;
 // constexpr days operator-(const day&  x, const day&  y) noexcept;
-// 
+//
 // constexpr day operator "" _d(unsigned long long d) noexcept;
 // std::ostream& operator<<(std::ostream& os, const day& d);
 
@@ -60,7 +60,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::day>{}, "");
-static_assert(!std::is_default_constructible<date::day>{}, "");
+static_assert( std::is_default_constructible<date::day>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::day>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::day>{}, "");
 static_assert( std::is_trivially_move_constructible<date::day>{}, "");

test/date_test/daypday.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/daysmday.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/daysmweekday.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/detail/decimal_format_seconds.pass.cpp

@@ -0,0 +1,141 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+// template <class Duration>
+// class decimal_format_seconds
+// {
+//     using CT = typename std::common_type<Duration, std::chrono::seconds>::type;
+//     using rep = typename CT::rep;
+// public:
+//     static unsigned constexpr width = detail::width<CT::period::den>::value < 19 ?
+//                                       detail::width<CT::period::den>::value : 6u;
+//     using precision = std::chrono::duration<rep,
+//                                             std::ratio<1, static_pow10<width>::value>>;
+// private:
+//     std::chrono::seconds s_;
+//     precision            sub_s_;
+// 
+// public:
+//     constexpr explicit decimal_format_seconds(const Duration& d) noexcept;
+// 
+//     constexpr std::chrono::seconds& seconds() noexcept;
+//     constexpr std::chrono::seconds seconds() const noexcept;
+//     constexpr precision subseconds() const noexcept;
+//     constexpr precision to_duration() const noexcept;
+// 
+//     template <class CharT, class Traits>
+//     friend
+//     std::basic_ostream<CharT, Traits>&
+//     operator<<(std::basic_ostream<CharT, Traits>& os, const decimal_format_seconds& x);
+// };
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+using fortnights = std::chrono::duration<date::weeks::rep,
+                                         date::detail::ratio_multiply<std::ratio<2>,
+                                                                      date::weeks::period>>;
+
+using microfortnights = std::chrono::duration<std::int64_t,
+                                              date::detail::ratio_multiply<fortnights::period,
+                                                                           std::micro>>;
+
+int
+main()
+{
+    using namespace date::detail;
+    using namespace std;
+    using namespace std::chrono;
+
+    {
+        using D = decimal_format_seconds<minutes>;
+        static_assert(is_same<D::precision, seconds>{}, "");
+        static_assert(D::width == 0, "");
+        D dfs{minutes{3}};
+        assert(dfs.seconds() == seconds{180});
+        assert(dfs.to_duration() == seconds{180});
+        ostringstream out;
+        out << dfs;
+        assert(out.str() == "180");
+    }
+    {
+        using D = decimal_format_seconds<seconds>;
+        static_assert(is_same<D::precision, seconds>{}, "");
+        static_assert(D::width == 0, "");
+        D dfs{seconds{3}};
+        assert(dfs.seconds() == seconds{3});
+        assert(dfs.to_duration() == seconds{3});
+        ostringstream out;
+        out << dfs;
+        assert(out.str() == "03");
+    }
+    {
+        using D = decimal_format_seconds<milliseconds>;
+        static_assert(D::width == 3, "");
+        D dfs{seconds{3}};
+        assert(dfs.seconds() == seconds{3});
+        assert(dfs.to_duration() == seconds{3});
+        assert(dfs.subseconds() == milliseconds{0});
+        ostringstream out;
+        out << dfs;
+        assert(out.str() == "03.000");
+    }
+    {
+        using D = decimal_format_seconds<milliseconds>;
+        static_assert(D::width == 3, "");
+        D dfs{milliseconds{3}};
+        assert(dfs.seconds() == seconds{0});
+        assert(dfs.to_duration() == milliseconds{3});
+        assert(dfs.subseconds() == milliseconds{3});
+        ostringstream out;
+        out << dfs;
+        assert(out.str() == "00.003");
+    }
+    {
+        using D = decimal_format_seconds<microfortnights>;
+        static_assert(D::width == 4, "");
+        D dfs{microfortnights{3}};
+        using S = D::precision;
+        assert(dfs.seconds() == seconds{3});
+        assert(dfs.to_duration() == S{36288});
+        assert(dfs.subseconds() == S{6288});
+        ostringstream out;
+        out << dfs;
+        assert(out.str() == "03.6288");
+    }
+    {
+        using CT = common_type<seconds, microfortnights>::type;
+        using D = decimal_format_seconds<CT>;
+        static_assert(D::width == 4, "");
+        D dfs{microfortnights{3}};
+        using S = D::precision;
+        assert(dfs.seconds() == seconds{3});
+        assert(dfs.to_duration() == S{36288});
+        assert(dfs.subseconds() == S{6288});
+        ostringstream out;
+        out << dfs;
+        assert(out.str() == "03.6288");
+    }
+}

test/date_test/detail/static_pow10.pass.cpp

@@ -0,0 +1,50 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+// template <unsigned exp>
+// struct static_pow10
+// {
+//     static constepxr std::uint64_t value = ...;
+// };
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+int
+main()
+{
+    using namespace date::detail;
+    static_assert(static_pow10<0>::value ==  1, "");
+    static_assert(static_pow10<1>::value ==  10, "");
+    static_assert(static_pow10<2>::value ==  100, "");
+    static_assert(static_pow10<3>::value ==  1000, "");
+    static_assert(static_pow10<4>::value ==  10000, "");
+    static_assert(static_pow10<5>::value ==  100000, "");
+    static_assert(static_pow10<6>::value ==  1000000, "");
+    static_assert(static_pow10<7>::value ==  10000000, "");
+    static_assert(static_pow10<8>::value ==  100000000, "");
+    static_assert(static_pow10<9>::value ==  1000000000, "");
+    static_assert(static_pow10<10>::value == 10000000000, "");
+}

test/date_test/detail/width.pass.cpp

@@ -0,0 +1,64 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+// width<n>::value is the number of fractional decimal digits in 1/n
+// width<0>::value and width<1>::value are defined to be 0
+// If 1/n takes more than 18 fractional decimal digits,
+//   the result is truncated to 19.
+// Example:  width<2>::value    ==  1
+// Example:  width<3>::value    == 19
+// Example:  width<4>::value    ==  2
+// Example:  width<10>::value   ==  1
+// Example:  width<1000>::value ==  3
+// template <std::uint64_t n>
+//
+// struct width
+// {
+//     static constexpr unsigned value = ...;
+// };
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+int
+main()
+{
+    using namespace date::detail;
+    static_assert(width<0>::value == 0, "");
+    static_assert(width<1>::value == 0, "");
+    static_assert(width<2>::value == 1, "");
+    static_assert(width<3>::value == 19, "");
+    static_assert(width<4>::value == 2, "");
+    static_assert(width<5>::value == 1, "");
+    static_assert(width<6>::value == 19, "");
+    static_assert(width<7>::value == 19, "");
+    static_assert(width<8>::value == 3, "");
+    static_assert(width<9>::value == 19, "");
+    static_assert(width<10>::value == 1, "");
+    static_assert(width<100>::value == 2, "");
+    static_assert(width<1000>::value == 3, "");
+    static_assert(width<10000>::value == 4, "");
+    static_assert(width<625>::value == 4, "");
+}

test/date_test/durations.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -21,22 +21,22 @@
 // SOFTWARE.
 
 // durations
-// 
+//
 // using days = std::chrono::duration
 //     <int, std::ratio_multiply<std::ratio<24>, std::chrono::hours::period>>;
-// 
+//
 // using weeks = std::chrono::duration
 //     <int, std::ratio_multiply<std::ratio<7>, days::period>>;
-// 
+//
 // using years = std::chrono::duration
 //     <int, std::ratio_multiply<std::ratio<146097, 400>, days::period>>;
-// 
+//
 // using months = std::chrono::duration
 //     <int, std::ratio_divide<years::period, std::ratio<12>>>;
-// 
+//
 // time_point
-// 
-// using day_point = std::chrono::time_point<std::chrono::system_clock, days>;
+//
+// using sys_days = std::chrono::time_point<std::chrono::system_clock, days>;
 
 #include "date.h"
 
@@ -54,7 +54,7 @@ static_assert(date::years{400} == date::days{146097}, "");
 static_assert(date::days{365} < date::years{1} && date::years{1} < date::days{366}, "");
 static_assert(date::weeks{52} < date::years{1} && date::years{1} < date::weeks{53}, "");
 
-static_assert(std::is_same<date::day_point::duration, date::days>{}, "");
+static_assert(std::is_same<date::sys_days::duration, date::days>{}, "");
 
 int
 main()

test/date_test/durations_output.pass.cpp

@@ -0,0 +1,328 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+
+void test_SI()
+{
+   using namespace std::chrono;
+   using namespace date;
+
+   std::ostringstream os;
+
+   // atto
+   {
+     duration<int, std::atto> d(13);
+     os << d;
+     assert(os.str() == "13as");
+     os.str("");
+   }
+
+   // femto
+   {
+     duration<int, std::femto> d(13);
+     os << d;
+     assert(os.str() == "13fs");
+     os.str("");
+   }
+
+   // pico
+   {
+     duration<int, std::pico> d(13);
+     os << d;
+     assert(os.str() == "13ps");
+     os.str("");
+   }
+
+   // nano
+   {
+     duration<int, std::nano> d(13);
+     os << d;
+     assert(os.str() == "13ns");
+     os.str("");
+   }
+
+   // mikro
+   {
+     duration<int, std::micro> d(13);
+     os << d;
+     assert(os.str() == "13\xC2\xB5s");
+     os.str("");
+   }
+
+   // milli
+   {
+     duration<int, std::milli> d(13);
+     os << d;
+     assert(os.str() == "13ms");
+     os.str("");
+   }
+
+   // centi
+   {
+     duration<int, std::centi> d(13);
+     os << d;
+     assert(os.str() == "13cs");
+     os.str("");
+   }
+
+   // deci
+   {
+     duration<int, std::deci> d(13);
+     os << d;
+     assert(os.str() == "13ds");
+     os.str("");
+   }
+
+   // seconds
+   {
+     duration<int> d(13);
+     os << d;
+     assert(os.str() == "13s");
+     os.str("");
+   }
+
+   // deca
+   {
+     duration<int, std::deca> d(13);
+     os << d;
+     assert(os.str() == "13das");
+     os.str("");
+   }
+
+   // hecto
+   {
+     duration<int, std::hecto> d(13);
+     os << d;
+     assert(os.str() == "13hs");
+     os.str("");
+   }
+
+   // kilo
+   {
+     duration<int, std::kilo> d(13);
+     os << d;
+     assert(os.str() == "13ks");
+     os.str("");
+   }
+
+   // mega
+   {
+     duration<int, std::mega> d(13);
+     os << d;
+     assert(os.str() == "13Ms");
+     os.str("");
+   }
+
+   // giga
+   {
+     duration<int, std::giga> d(13);
+     os << d;
+     assert(os.str() == "13Gs");
+     os.str("");
+   }
+
+   // tera
+   {
+     duration<int, std::tera> d(13);
+     os << d;
+     assert(os.str() == "13Ts");
+     os.str("");
+   }
+
+   // peta
+   {
+     duration<int, std::peta> d(13);
+     os << d;
+     assert(os.str() == "13Ps");
+     os.str("");
+   }
+
+   // femto
+   {
+     duration<int, std::exa> d(13);
+     os << d;
+     assert(os.str() == "13Es");
+     os.str("");
+   }
+}
+
+void test_calendar()
+{
+   using namespace std::chrono;
+   using namespace date;
+
+   std::ostringstream os;
+
+   // minutes
+   {
+      minutes d(13);
+      os << d;
+      assert(os.str() == "13min");
+      os.str("");
+   }
+
+   // hours
+   {
+      hours d(13);
+      os << d;
+      assert(os.str() == "13h");
+      os.str("");
+   }
+
+   // days
+   {
+      days d(13);
+      os << d;
+      assert(os.str() == "13d");
+      os.str("");
+   }
+}
+
+void test_integral_scale()
+{
+   using namespace std::chrono;
+   using namespace date;
+
+   std::ostringstream os;
+
+   // ratio 123 / 1
+   {
+      duration<int, std::ratio<123, 1>> d(13);
+      os << d;
+      assert(os.str() == "13[123]s");
+      os.str("");
+   }
+
+   // ratio 100 / 4 = ratio 25 / 1
+   {
+      duration<int, std::ratio<25, 1>> d(13);
+      os << d;
+      assert(os.str() == "13[25]s");
+      os.str("");
+   }
+
+   // weeks = ratio 7 * 24 * 60 * 60 / 1 = ratio 604800 / 1
+   {
+      weeks d(13);
+      os << d;
+      assert(os.str() == "13[604800]s");
+      os.str("");
+   }
+
+   // years = 146097/400 days = ratio 146097/400 * 24 * 60 * 60 = ratio 31556952 / 1
+   {
+      years d(13);
+      os << d;
+      assert(os.str() == "13[31556952]s");
+      os.str("");
+   }
+
+   // months = 1/12 years = ratio 1/12 * 31556952  = ratio 2629746 / 1
+   {
+      months d(13);
+      os << d;
+      assert(os.str() == "13[2629746]s");
+      os.str("");
+   }
+}
+
+void test_ratio_scale()
+{
+   using namespace std::chrono;
+   using namespace date;
+
+   std::ostringstream os;
+
+   // ratio 1 / 2
+   {
+      duration<int, std::ratio<1, 2>> d(13);
+      os << d;
+      assert(os.str() == "13[1/2]s");
+      os.str("");
+   }
+
+   // ratio 100 / 3
+   {
+      duration<int, std::ratio<100, 3>> d(13);
+      os << d;
+      assert(os.str() == "13[100/3]s");
+      os.str("");
+   }
+
+   // ratio 100 / 6 = ratio 50 / 3
+   {
+      duration<int, std::ratio<100, 6>> d(13);
+      os << d;
+      assert(os.str() == "13[50/3]s");
+      os.str("");
+   }
+}
+
+void test_constexpr()
+{
+  using date::detail::get_units;
+
+  CONSTCD11 auto as = get_units<char>(std::atto{});
+  CONSTCD11 auto fs = get_units<char>(std::femto{});
+  CONSTCD11 auto ps = get_units<char>(std::pico{});
+  CONSTCD11 auto ns = get_units<char>(std::nano{});
+  CONSTCD11 auto us = get_units<char>(std::micro{});
+  CONSTCD11 auto usw = get_units<wchar_t>(std::micro{});
+  CONSTCD11 auto ms = get_units<char>(std::milli{});
+  CONSTCD11 auto cs = get_units<char>(std::centi{});
+  CONSTCD11 auto ds = get_units<char>(std::deci{});
+  CONSTCD11 auto s = get_units<char>(std::ratio<1>{});
+  CONSTCD11 auto das = get_units<char>(std::deca{});
+  CONSTCD11 auto hs = get_units<char>(std::hecto{});
+  CONSTCD11 auto ks = get_units<char>(std::kilo{});
+  CONSTCD11 auto Ms = get_units<char>(std::mega{});
+  CONSTCD11 auto Gs = get_units<char>(std::giga{});
+  CONSTCD11 auto Ts = get_units<char>(std::tera{});
+  CONSTCD11 auto Ps = get_units<char>(std::peta{});
+  CONSTCD11 auto Es = get_units<char>(std::exa{});
+  (void)as, (void)fs, (void)ps, (void)ns, (void)usw, (void)us,
+  (void)ms, (void)cs, (void)ds, (void)s,  (void)das, (void)hs,
+  (void)ks, (void)Ms, (void)Gs, (void)Ts, (void)Ps,  (void)Es;
+
+  CONSTCD11 auto min = get_units<char>(std::ratio<60>{});
+  CONSTCD11 auto h = get_units<char>(std::ratio<3600>{});
+  CONSTCD11 auto d = get_units<char>(std::ratio<86400>{});
+  (void)min, (void)h, (void)d;
+
+  CONSTCD14 auto integer = get_units<char>(std::ratio<123>{});
+  CONSTCD14 auto ratio = get_units<char>(std::ratio<123, 3>{});
+  (void)integer, (void)ratio;
+}
+
+int
+main()
+{
+  test_SI();
+  test_calendar();
+  test_integral_scale();
+  test_ratio_scale();
+}

test/date_test/format/century.pass.cpp

@@ -0,0 +1,117 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+int
+main()
+{
+    using namespace date;
+    using namespace std::chrono;
+    std::ostringstream os;
+    os << format("%C", sys_days{jun/1/20001});
+    assert(os.str() == "200");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/20000});
+    assert(os.str() == "200");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/19999});
+    assert(os.str() == "199");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/2001});
+    assert(os.str() == "20");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/2000});
+    assert(os.str() == "20");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/1999});
+    assert(os.str() == "19");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/101});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/100});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/99});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/1});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/0});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-1});
+    assert(os.str() == "-01");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-99});
+    assert(os.str() == "-01");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-100});
+    assert(os.str() == "-01");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-101});
+    assert(os.str() == "-02");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-1999});
+    assert(os.str() == "-20");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-2000});
+    assert(os.str() == "-20");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-2001});
+    assert(os.str() == "-21");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-19999});
+    assert(os.str() == "-200");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-20000});
+    assert(os.str() == "-200");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-20001});
+    assert(os.str() == "-201");
+}

test/date_test/format/misc.pass.cpp

@@ -0,0 +1,52 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "date.h"
+#include <cassert>
+#include <sstream>
+
+template <class T>
+void
+test(const std::string& in_fmt, const std::string& input,
+     const std::string& out_fmt, const std::string& output)
+{
+    using namespace date;
+    std::istringstream in{input};
+    T t;
+    in >> parse(in_fmt, t);
+    assert(!in.fail());
+    auto s = format(out_fmt, t);
+    assert(s == output);
+}
+
+int
+main()
+{
+    using namespace date;
+    test<year>("%Y", "2017", "%Y", "2017");
+    test<month>("%m", "3", "%m", "03");
+    test<day>("%d", "25", "%d", "25");
+    test<year_month>("%Y-%m", "2017-03", "%Y-%m", "2017-03");
+    test<year_month>("%y%m", "1703", "%Y-%m", "2017-03");
+    test<month_day>("%m/%d", "3/25", "%m/%d", "03/25");
+    test<weekday>("%w", "3", "%w", "3");
+}

test/date_test/format/range.pass.cpp

@@ -0,0 +1,78 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+using fortnights = std::chrono::duration<date::weeks::rep,
+                                         date::detail::ratio_multiply<std::ratio<2>,
+                                                                      date::weeks::period>>;
+
+using microfortnights = std::chrono::duration<std::int64_t,
+                                              date::detail::ratio_multiply<fortnights::period,
+                                                                           std::micro>>;
+
+int
+main()
+{
+    using namespace date;
+    using namespace std::chrono;
+    std::ostringstream os;
+    os << format("%F %T", sys_days{jan/1/year::min()});
+    assert(os.str() == "-32767-01-01 00:00:00");
+    os.str("");
+    os << format("%F %T", sys_days{dec/last/year::max()});
+    assert(os.str() == "32767-12-31 00:00:00");
+    os.str("");
+    os << format("%F %T", sys_days{dec/last/year::max()} + hours{23} + minutes{59} +
+                                                  seconds{59} + microseconds{999999});
+    assert(os.str() == "32767-12-31 23:59:59.999999");
+    os.str("");
+
+    os << format("%Y-%m-%d %H:%M:%S", sys_days{jan/1/year::min()});
+    assert(os.str() == "-32767-01-01 00:00:00");
+    os.str("");
+    os << format("%Y-%m-%d %H:%M:%S", sys_days{dec/last/year::max()});
+    assert(os.str() == "32767-12-31 00:00:00");
+    os.str("");
+    os << format("%Y-%m-%d %H:%M:%S", sys_days{dec/last/year::max()} + hours{23} +
+                                        minutes{59} + seconds{59} + microseconds{999999});
+    assert(os.str() == "32767-12-31 23:59:59.999999");
+    os.str("");
+
+    os << format("%F %T", sys_days{jan/1/year::min()} + microfortnights{1});
+    assert(os.str() == "-32767-01-01 00:00:01.2096");
+    os.str("");
+    os << format("%F %T", sys_days{dec/last/year::max()} + microfortnights{1});
+    assert(os.str() == "32767-12-31 00:00:01.2096");
+    os.str("");
+
+    os << format("%F", jan/1/year::min());
+    assert(os.str() == "-32767-01-01");
+    os.str("");
+    os << format("%F", dec/last/year::max());
+    assert(os.str() == "32767-12-31");
+    os.str("");
+}

test/date_test/format/two_dight_year.pass.cpp

@@ -0,0 +1,121 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+int
+main()
+{
+    using namespace date;
+    using namespace std::chrono;
+    std::ostringstream os;
+    os << format("%y", sys_days{jun/1/20001});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/20000});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/19999});
+    assert(os.str() == "99");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/2001});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/2000});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/1999});
+    assert(os.str() == "99");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/101});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/100});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/99});
+    assert(os.str() == "99");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/1});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/0});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-1});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-99});
+    assert(os.str() == "99");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-100});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-101});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-1999});
+    assert(os.str() == "99");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-2000});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-2001});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-19999});
+    assert(os.str() == "99");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-20000});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-20001});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/year::min()});
+    assert(os.str() == "67");
+}

test/date_test/last.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/make_time.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -27,27 +27,6 @@
 // time_of_day<std::chrono::duration<Rep, Period>>
 // make_time(std::chrono::duration<Rep, Period> d) noexcept;
 
-// constexpr
-// time_of_day<std::chrono::hours>
-// make_time(std::chrono::hours h, unsigned md) noexcept;
-
-// constexpr
-// time_of_day<std::chrono::minutes>
-// make_time(std::chrono::hours h, std::chrono::minutes m, unsigned md) noexcept;
-
-// constexpr
-// time_of_day<std::chrono::seconds>
-// make_time(std::chrono::hours h, std::chrono::minutes m, std::chrono::seconds s,
-//           unsigned md) noexcept;
-
-// template <class Rep, class Period,
-//           class = typename std::enable_if<std::ratio_less<Period,
-//                                                           std::ratio<1>>::value>::type>
-// constexpr
-// time_of_day<std::chrono::duration<Rep, Period>>
-// make_time(std::chrono::hours h, std::chrono::minutes m, std::chrono::seconds s,
-//           std::chrono::duration<Rep, Period> sub_s, unsigned md) noexcept;
-
 #include "date.h"
 
 #include <cassert>
@@ -68,7 +47,6 @@ main()
         assert(tod.minutes() == minutes{7});
         assert(tod.seconds() == seconds{9});
         assert(tod.subseconds() == nanoseconds{22});
-        assert(tod.mode() == 0);
     }
     {
         static_assert(is_same<decltype(make_time(microseconds{18429000022})),
@@ -78,7 +56,6 @@ main()
         assert(tod.minutes() == minutes{7});
         assert(tod.seconds() == seconds{9});
         assert(tod.subseconds() == microseconds{22});
-        assert(tod.mode() == 0);
     }
     {
         static_assert(is_same<decltype(make_time(seconds{18429})),
@@ -87,7 +64,6 @@ main()
         assert(tod.hours() == hours{5});
         assert(tod.minutes() == minutes{7});
         assert(tod.seconds() == seconds{9});
-        assert(tod.mode() == 0);
     }
     {
         static_assert(is_same<decltype(make_time(minutes{307})),
@@ -95,70 +71,11 @@ main()
         auto tod = make_time(minutes{307});
         assert(tod.hours() == hours{5});
         assert(tod.minutes() == minutes{7});
-        assert(tod.mode() == 0);
     }
     {
         static_assert(is_same<decltype(make_time(hours{5})),
                               time_of_day<hours>>{}, "");
         auto tod = make_time(hours{5});
         assert(tod.hours() == hours{5});
-        assert(tod.mode() == 0);
-    }
-    {
-        static_assert(is_same<decltype(make_time(hours{5}, minutes{7}, seconds{9},
-                                                 nanoseconds{22}, pm)),
-                              time_of_day<nanoseconds>>{}, "");
-        auto tod = make_time(hours{5}, minutes{7}, seconds{9}, nanoseconds{22}, pm);
-        assert(tod.hours() == hours{5});
-        assert(tod.minutes() == minutes{7});
-        assert(tod.seconds() == seconds{9});
-        assert(tod.subseconds() == nanoseconds{22});
-        assert(tod.mode() == pm);
-    }
-    {
-        static_assert(is_same<decltype(make_time(hours{5}, minutes{7}, seconds{9},
-                                                 microseconds{22}, 0)),
-                              time_of_day<microseconds>>{}, "");
-        auto tod = make_time(hours{5}, minutes{7}, seconds{9}, microseconds{22}, 0);
-        assert(tod.hours() == hours{5});
-        assert(tod.minutes() == minutes{7});
-        assert(tod.seconds() == seconds{9});
-        assert(tod.subseconds() == microseconds{22});
-        assert(tod.mode() == 0);
-    }
-    {
-        static_assert(is_same<decltype(make_time(hours{5}, minutes{7}, seconds{9},
-                                                 milliseconds{22}, am)),
-                              time_of_day<milliseconds>>{}, "");
-        auto tod = make_time(hours{5}, minutes{7}, seconds{9}, milliseconds{22}, am);
-        assert(tod.hours() == hours{5});
-        assert(tod.minutes() == minutes{7});
-        assert(tod.seconds() == seconds{9});
-        assert(tod.subseconds() == milliseconds{22});
-        assert(tod.mode() == am);
-    }
-    {
-        static_assert(is_same<decltype(make_time(hours{5}, minutes{7}, seconds{9}, am)),
-                              time_of_day<seconds>>{}, "");
-        auto tod = make_time(hours{5}, minutes{7}, seconds{9}, am);
-        assert(tod.hours() == hours{5});
-        assert(tod.minutes() == minutes{7});
-        assert(tod.seconds() == seconds{9});
-        assert(tod.mode() == am);
-    }
-    {
-        static_assert(is_same<decltype(make_time(hours{5}, minutes{7}, pm)),
-                              time_of_day<minutes>>{}, "");
-        auto tod = make_time(hours{5}, minutes{7}, pm);
-        assert(tod.hours() == hours{5});
-        assert(tod.minutes() == minutes{7});
-        assert(tod.mode() == pm);
-    }
-    {
-        static_assert(is_same<decltype(make_time(hours{5}, 0)),
-                              time_of_day<hours>>{}, "");
-        auto tod = make_time(hours{5}, 0);
-        assert(tod.hours() == hours{5});
-        assert(tod.mode() == 0);
     }
 }

test/date_test/month.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -25,31 +25,31 @@
 //     unsigned char m_;
 // public:
 //     explicit constexpr month(unsigned m) noexcept;
-// 
+//
 //     month& operator++()    noexcept;
 //     month  operator++(int) noexcept;
 //     month& operator--()    noexcept;
 //     month  operator--(int) noexcept;
-// 
+//
 //     month& operator+=(const months& m) noexcept;
 //     month& operator-=(const months& m) noexcept;
-// 
+//
 //     constexpr explicit operator unsigned() const noexcept;
 //     constexpr bool ok() const noexcept;
 // };
-// 
+//
 // constexpr bool operator==(const month& x, const month& y) noexcept;
 // constexpr bool operator!=(const month& x, const month& y) noexcept;
 // constexpr bool operator< (const month& x, const month& y) noexcept;
 // constexpr bool operator> (const month& x, const month& y) noexcept;
 // constexpr bool operator<=(const month& x, const month& y) noexcept;
 // constexpr bool operator>=(const month& x, const month& y) noexcept;
-// 
+//
 // constexpr month  operator+(const month&  x, const months& y) noexcept;
 // constexpr month  operator+(const months& x,  const month& y) noexcept;
 // constexpr month  operator-(const month&  x, const months& y) noexcept;
 // constexpr months operator-(const month&  x,  const month& y) noexcept;
-// 
+//
 // std::ostream& operator<<(std::ostream& os, const month& m);
 
 // constexpr month jan{1};
@@ -72,7 +72,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::month>{}, "");
-static_assert(!std::is_default_constructible<date::month>{}, "");
+static_assert( std::is_default_constructible<date::month>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::month>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::month>{}, "");
 static_assert( std::is_trivially_move_constructible<date::month>{}, "");

test/date_test/month_day.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -24,10 +24,10 @@
 // {
 // public:
 //     constexpr month_day(const date::month& m, const date::day& d) noexcept;
-// 
+//
 //     constexpr date::month month() const noexcept;
 //     constexpr date::day   day() const noexcept;
-// 
+//
 //     constexpr bool ok() const noexcept;
 // };
 
@@ -47,7 +47,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::month_day>{}, "");
-static_assert(!std::is_default_constructible<date::month_day>{}, "");
+static_assert( std::is_default_constructible<date::month_day>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::month_day>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::month_day>{}, "");
 static_assert( std::is_trivially_move_constructible<date::month_day>{}, "");

test/date_test/month_day_last.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -24,7 +24,7 @@
 // {
 // public:
 //     constexpr explicit month_day_last(const date::month& m) noexcept;
-// 
+//
 //     constexpr date::month month() const noexcept;
 //     constexpr bool ok() const noexcept;
 // };

test/date_test/month_weekday.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -25,10 +25,10 @@
 // public:
 //     constexpr month_weekday(const date::month& m,
 //                               const date::weekday_indexed& wdi) noexcept;
-// 
+//
 //     constexpr date::month           month()           const noexcept;
 //     constexpr date::weekday_indexed weekday_indexed() const noexcept;
-// 
+//
 //     constexpr bool ok() const noexcept;
 // };
 

test/date_test/month_weekday_last.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -25,10 +25,10 @@
 // public:
 //     constexpr month_weekday_last(const date::month& m,
 //                                  const date::weekday_last& wdl) noexcept;
-// 
+//
 //     constexpr date::month        month()        const noexcept;
 //     constexpr date::weekday_last weekday_last() const noexcept;
-// 
+//
 //     constexpr bool ok() const noexcept;
 // };
 

test/date_test/month_weekday_last_less.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/month_weekday_less.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/monthpmonth.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/months_m_year_month.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/months_m_year_month_day.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/monthsmmonth.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/multi_year_duration_addition.pass.cpp

@@ -0,0 +1,487 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+#include "date.h"
+#include <chrono>
+#include <cassert>
+#include <type_traits>
+
+#define CPP11_ASSERT(...) static_assert(__VA_ARGS__, "")
+
+#if __cplusplus >= 201402
+// C++14
+#  define CPP14_ASSERT(...) static_assert(__VA_ARGS__, "")
+#else
+// C++11
+#  define CPP14_ASSERT(...) assert(__VA_ARGS__)
+#endif
+
+#define NOEXCEPT_ASSERT(...) static_assert(noexcept(__VA_ARGS__), "")
+
+//Invocation involves a conversion between duration that is currently
+//not marked as noexcept.
+#define NOEXCEPT_CONVERSION(...)
+
+template<typename T>
+constexpr T copy(T const& t) noexcept { return t; }
+
+struct ConvertibleToYears
+{
+   CONSTCD11 operator date::years() const NOEXCEPT
+   { return date::years{1}; };
+};
+
+struct ConvertibleToMonths
+{
+   CONSTCD11 operator date::months() const NOEXCEPT
+   { return date::months{1}; };
+};
+
+struct ConvertibleToYearsAndMonths
+{
+   CONSTCD11 operator date::years() const NOEXCEPT
+   { return date::years{1}; };
+
+   CONSTCD11 operator date::months() const NOEXCEPT
+   { return date::months{1}; };
+
+};
+
+int
+main()
+{
+    using namespace date;
+    using namespace std::chrono;
+
+    using decades = duration<int, date::detail::ratio_multiply<std::ratio<10>, years::period>>;
+    using decamonths = duration<int, date::detail::ratio_multiply<std::ratio<10>, months::period>>;
+
+    constexpr months one_month{1};
+    constexpr years one_year{1};
+    constexpr decades one_decade{1};
+    constexpr decamonths one_decamonth{1};
+
+    constexpr ConvertibleToMonths custom_month;
+    constexpr ConvertibleToYears custom_year;
+    constexpr ConvertibleToYearsAndMonths prefer_year;
+    
+
+    {
+       constexpr year_month ym = 2001_y/feb;
+       CPP14_ASSERT(ym + one_month == 2001_y/mar);
+       NOEXCEPT_ASSERT(ym + one_month);
+       CPP14_ASSERT(one_month + ym == 2001_y/mar);
+       NOEXCEPT_ASSERT(one_month + ym);
+       CPP14_ASSERT(ym - one_month == 2001_y/jan);
+       NOEXCEPT_ASSERT(ym - one_month);
+       CPP14_ASSERT((copy(ym) += one_month) == 2001_y/mar);
+       NOEXCEPT_ASSERT(copy(ym) += one_month);
+       CPP14_ASSERT((copy(ym) -= one_month) == 2001_y/jan);
+       NOEXCEPT_ASSERT(copy(ym) -= one_month);
+      
+       CPP11_ASSERT(ym + one_year == 2002_y/feb);
+       NOEXCEPT_ASSERT(ym + one_year);
+       CPP11_ASSERT(one_year + ym == 2002_y/feb);
+       NOEXCEPT_ASSERT(one_year + ym);
+       CPP11_ASSERT(ym - one_year == 2000_y/feb);
+       NOEXCEPT_ASSERT(ym - one_year);
+       CPP14_ASSERT((copy(ym) += one_year) == 2002_y/feb);
+       NOEXCEPT_ASSERT(copy(ym) += one_year);
+       CPP14_ASSERT((copy(ym) -= one_year) == 2000_y/feb);
+       NOEXCEPT_ASSERT(copy(ym) -= one_year);
+
+       CPP11_ASSERT(ym + one_decade == 2011_y/feb);
+       NOEXCEPT_CONVERSION(ym + one_decade);
+       CPP11_ASSERT(one_decade + ym == 2011_y/feb);
+       NOEXCEPT_CONVERSION(one_decade + ym);
+       CPP11_ASSERT(ym - one_decade == 1991_y/feb);
+       NOEXCEPT_CONVERSION(ym - one_decade);
+       CPP14_ASSERT((copy(ym) += one_decade) == 2011_y/feb);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decade);
+       CPP14_ASSERT((copy(ym) -= one_decade) == 1991_y/feb);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decade);
+
+       CPP14_ASSERT(ym + one_decamonth == 2001_y/dec);
+       NOEXCEPT_CONVERSION(ym + one_decamonth);
+       CPP14_ASSERT(one_decamonth + ym  == 2001_y/dec);
+       NOEXCEPT_CONVERSION(one_decamonth + ym);
+       CPP14_ASSERT(ym - one_decamonth == 2000_y/apr);
+       NOEXCEPT_CONVERSION(ym - one_decamonth);
+       CPP14_ASSERT((copy(ym) += one_decamonth) == 2001_y/dec);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decamonth);
+       CPP14_ASSERT((copy(ym) -= one_decamonth) == 2000_y/apr);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decamonth);
+
+       CPP14_ASSERT(ym + custom_month == 2001_y/mar);
+       NOEXCEPT_ASSERT(ym + custom_month);
+       CPP14_ASSERT(custom_month + ym == 2001_y/mar);
+       NOEXCEPT_ASSERT(custom_month + ym);
+       CPP14_ASSERT(ym - custom_month == 2001_y/jan);
+       NOEXCEPT_ASSERT(ym - custom_month);
+       CPP14_ASSERT((copy(ym) += custom_month) == 2001_y/mar);
+       NOEXCEPT_ASSERT(copy(ym) += custom_month);
+       CPP14_ASSERT((copy(ym) -= custom_month) == 2001_y/jan);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_month);
+      
+       CPP11_ASSERT(ym + custom_year == 2002_y/feb);
+       NOEXCEPT_ASSERT(ym + custom_year);
+       CPP11_ASSERT(custom_year + ym == 2002_y/feb);
+       NOEXCEPT_ASSERT(custom_year + ym);
+       CPP11_ASSERT(ym - custom_year == 2000_y/feb);
+       NOEXCEPT_ASSERT(ym - custom_year);
+       CPP14_ASSERT((copy(ym) += custom_year) == 2002_y/feb);
+       NOEXCEPT_ASSERT(copy(ym) += custom_year);
+       CPP14_ASSERT((copy(ym) -= custom_year) == 2000_y/feb);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_year);
+
+       CPP11_ASSERT(ym + prefer_year == 2002_y/feb);
+       NOEXCEPT_ASSERT(ym + prefer_year);
+       CPP11_ASSERT(prefer_year + ym == 2002_y/feb);
+       NOEXCEPT_ASSERT(prefer_year + ym);
+       CPP11_ASSERT(ym - prefer_year == 2000_y/feb);
+       NOEXCEPT_ASSERT(ym - prefer_year);
+       CPP14_ASSERT((copy(ym) += prefer_year) == 2002_y/feb);
+       NOEXCEPT_ASSERT(copy(ym) += prefer_year);
+       CPP14_ASSERT((copy(ym) -= prefer_year) == 2000_y/feb);
+       NOEXCEPT_ASSERT(copy(ym) -= prefer_year);
+    }
+
+    {
+       constexpr year_month_day ym = 2001_y/feb/10;
+       CPP14_ASSERT(ym + one_month == 2001_y/mar/10);
+       NOEXCEPT_ASSERT(ym + one_month);
+       CPP14_ASSERT(one_month + ym == 2001_y/mar/10);
+       NOEXCEPT_ASSERT(one_month + ym);
+       CPP14_ASSERT(ym - one_month == 2001_y/jan/10);
+       NOEXCEPT_ASSERT(ym - one_month);
+       CPP14_ASSERT((copy(ym) += one_month) == 2001_y/mar/10);
+       NOEXCEPT_ASSERT(copy(ym) += one_month);
+       CPP14_ASSERT((copy(ym) -= one_month) == 2001_y/jan/10);
+       NOEXCEPT_ASSERT(copy(ym) -= one_month);
+      
+       CPP11_ASSERT(ym + one_year == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(ym + one_year);
+       CPP11_ASSERT(one_year + ym == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(one_year + ym);
+       CPP11_ASSERT(ym - one_year == 2000_y/feb/10);
+       NOEXCEPT_ASSERT(ym - one_year);
+       CPP14_ASSERT((copy(ym) += one_year) == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(copy(ym) += one_year);
+       CPP14_ASSERT((copy(ym) -= one_year) == 2000_y/feb/10);
+       NOEXCEPT_ASSERT(copy(ym) -= one_year);
+
+       CPP11_ASSERT(ym + one_decade == 2011_y/feb/10);
+       NOEXCEPT_CONVERSION(ym + one_decade);
+       CPP11_ASSERT(one_decade + ym == 2011_y/feb/10);
+       NOEXCEPT_CONVERSION(one_decade + ym);
+       CPP11_ASSERT(ym - one_decade == 1991_y/feb/10);
+       NOEXCEPT_CONVERSION(ym - one_decade);
+       CPP14_ASSERT((copy(ym) += one_decade) == 2011_y/feb/10);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decade);
+       CPP14_ASSERT((copy(ym) -= one_decade) == 1991_y/feb/10);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decade);
+
+       CPP14_ASSERT(ym + one_decamonth == 2001_y/dec/10);
+       NOEXCEPT_CONVERSION(ym + one_decamonth);
+       CPP14_ASSERT(one_decamonth + ym  == 2001_y/dec/10);
+       NOEXCEPT_CONVERSION(one_decamonth + ym);
+       CPP14_ASSERT(ym - one_decamonth == 2000_y/apr/10);
+       NOEXCEPT_CONVERSION(ym - one_decamonth);
+       CPP14_ASSERT((copy(ym) += one_decamonth) == 2001_y/dec/10);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decamonth);
+       CPP14_ASSERT((copy(ym) -= one_decamonth) == 2000_y/apr/10);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decamonth);
+
+       CPP14_ASSERT(ym + custom_month == 2001_y/mar/10);
+       NOEXCEPT_ASSERT(ym + custom_month);
+       CPP14_ASSERT(custom_month + ym == 2001_y/mar/10);
+       NOEXCEPT_ASSERT(custom_month + ym);
+       CPP14_ASSERT(ym - custom_month == 2001_y/jan/10);
+       NOEXCEPT_ASSERT(ym - custom_month);
+       CPP14_ASSERT((copy(ym) += custom_month) == 2001_y/mar/10);
+       NOEXCEPT_ASSERT(copy(ym) += custom_month);
+       CPP14_ASSERT((copy(ym) -= custom_month) == 2001_y/jan/10);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_month);
+      
+       CPP11_ASSERT(ym + custom_year == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(ym + custom_year);
+       CPP11_ASSERT(custom_year + ym == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(custom_year + ym);
+       CPP11_ASSERT(ym - custom_year == 2000_y/feb/10);
+       NOEXCEPT_ASSERT(ym - custom_year);
+       CPP14_ASSERT((copy(ym) += custom_year) == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(copy(ym) += custom_year);
+       CPP14_ASSERT((copy(ym) -= custom_year) == 2000_y/feb/10);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_year);
+
+       CPP11_ASSERT(ym + prefer_year == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(ym + prefer_year);
+       CPP11_ASSERT(prefer_year + ym == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(prefer_year + ym);
+       CPP11_ASSERT(ym - prefer_year == 2000_y/feb/10);
+       NOEXCEPT_ASSERT(ym - prefer_year);
+       CPP14_ASSERT((copy(ym) += prefer_year) == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(copy(ym) += prefer_year);
+       CPP14_ASSERT((copy(ym) -= prefer_year) == 2000_y/feb/10);
+       NOEXCEPT_ASSERT(copy(ym) -= prefer_year);
+    }
+
+    {
+       constexpr year_month_day_last ym = 2001_y/feb/last;
+       CPP14_ASSERT(ym + one_month == 2001_y/mar/last);
+       NOEXCEPT_ASSERT(ym + one_month);
+       CPP14_ASSERT(one_month + ym == 2001_y/mar/last);
+       NOEXCEPT_ASSERT(one_month + ym);
+       CPP14_ASSERT(ym - one_month == 2001_y/jan/last);
+       NOEXCEPT_ASSERT(ym - one_month);
+       CPP14_ASSERT((copy(ym) += one_month) == 2001_y/mar/last);
+       NOEXCEPT_ASSERT(copy(ym) += one_month);
+       CPP14_ASSERT((copy(ym) -= one_month) == 2001_y/jan/last);
+       NOEXCEPT_ASSERT(copy(ym) -= one_month);
+      
+       CPP11_ASSERT(ym + one_year == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(ym + one_year);
+       CPP11_ASSERT(one_year + ym == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(one_year + ym);
+       CPP11_ASSERT(ym - one_year == 2000_y/feb/last);
+       NOEXCEPT_ASSERT(ym - one_year);
+       CPP14_ASSERT((copy(ym) += one_year) == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(copy(ym) += one_year);
+       CPP14_ASSERT((copy(ym) -= one_year) == 2000_y/feb/last);
+       NOEXCEPT_ASSERT(copy(ym) -= one_year);
+
+       CPP11_ASSERT(ym + one_decade == 2011_y/feb/last);
+       NOEXCEPT_CONVERSION(ym + one_decade);
+       CPP11_ASSERT(one_decade + ym == 2011_y/feb/last);
+       NOEXCEPT_CONVERSION(one_decade + ym);
+       CPP11_ASSERT(ym - one_decade == 1991_y/feb/last);
+       NOEXCEPT_CONVERSION(ym - one_decade);
+       CPP14_ASSERT((copy(ym) += one_decade) == 2011_y/feb/last);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decade);
+       CPP14_ASSERT((copy(ym) -= one_decade) == 1991_y/feb/last);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decade);
+
+       CPP14_ASSERT(ym + one_decamonth == 2001_y/dec/last);
+       NOEXCEPT_CONVERSION(ym + one_decamonth);
+       CPP14_ASSERT(one_decamonth + ym  == 2001_y/dec/last);
+       NOEXCEPT_CONVERSION(one_decamonth + ym);
+       CPP14_ASSERT(ym - one_decamonth == 2000_y/apr/last);
+       NOEXCEPT_CONVERSION(ym - one_decamonth);
+       CPP14_ASSERT((copy(ym) += one_decamonth) == 2001_y/dec/last);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decamonth);
+       CPP14_ASSERT((copy(ym) -= one_decamonth) == 2000_y/apr/last);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decamonth);
+
+       CPP14_ASSERT(ym + custom_month == 2001_y/mar/last);
+       NOEXCEPT_ASSERT(ym + custom_month);
+       CPP14_ASSERT(custom_month + ym == 2001_y/mar/last);
+       NOEXCEPT_ASSERT(custom_month + ym);
+       CPP14_ASSERT(ym - custom_month == 2001_y/jan/last);
+       NOEXCEPT_ASSERT(ym - custom_month);
+       CPP14_ASSERT((copy(ym) += custom_month) == 2001_y/mar/last);
+       NOEXCEPT_ASSERT(copy(ym) += custom_month);
+       CPP14_ASSERT((copy(ym) -= custom_month) == 2001_y/jan/last);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_month);
+      
+       CPP11_ASSERT(ym + custom_year == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(ym + custom_year);
+       CPP11_ASSERT(custom_year + ym == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(custom_year + ym);
+       CPP11_ASSERT(ym - custom_year == 2000_y/feb/last);
+       NOEXCEPT_ASSERT(ym - custom_year);
+       CPP14_ASSERT((copy(ym) += custom_year) == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(copy(ym) += custom_year);
+       CPP14_ASSERT((copy(ym) -= custom_year) == 2000_y/feb/last);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_year);
+
+       CPP11_ASSERT(ym + prefer_year == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(ym + prefer_year);
+       CPP11_ASSERT(prefer_year + ym == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(prefer_year + ym);
+       CPP11_ASSERT(ym - prefer_year == 2000_y/feb/last);
+       NOEXCEPT_ASSERT(ym - prefer_year);
+       CPP14_ASSERT((copy(ym) += prefer_year) == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(copy(ym) += prefer_year);
+       CPP14_ASSERT((copy(ym) -= prefer_year) == 2000_y/feb/last);
+       NOEXCEPT_ASSERT(copy(ym) -= prefer_year);
+    }
+
+    {
+       constexpr year_month_weekday ym = 2001_y/feb/fri[4];
+       CPP14_ASSERT(ym + one_month == 2001_y/mar/fri[4]);
+       NOEXCEPT_ASSERT(ym + one_month);
+       CPP14_ASSERT(one_month + ym == 2001_y/mar/fri[4]);
+       NOEXCEPT_ASSERT(one_month + ym);
+       CPP14_ASSERT(ym - one_month == 2001_y/jan/fri[4]);
+       NOEXCEPT_ASSERT(ym - one_month);
+       CPP14_ASSERT((copy(ym) += one_month) == 2001_y/mar/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) += one_month);
+       CPP14_ASSERT((copy(ym) -= one_month) == 2001_y/jan/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) -= one_month);
+      
+       CPP11_ASSERT(ym + one_year == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(ym + one_year);
+       CPP11_ASSERT(one_year + ym == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(one_year + ym);
+       CPP11_ASSERT(ym - one_year == 2000_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(ym - one_year);
+       CPP14_ASSERT((copy(ym) += one_year) == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) += one_year);
+       CPP14_ASSERT((copy(ym) -= one_year) == 2000_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) -= one_year);
+
+       CPP11_ASSERT(ym + one_decade == 2011_y/feb/fri[4]);
+       NOEXCEPT_CONVERSION(ym + one_decade);
+       CPP11_ASSERT(one_decade + ym == 2011_y/feb/fri[4]);
+       NOEXCEPT_CONVERSION(one_decade + ym);
+       CPP11_ASSERT(ym - one_decade == 1991_y/feb/fri[4]);
+       NOEXCEPT_CONVERSION(ym - one_decade);
+       CPP14_ASSERT((copy(ym) += one_decade) == 2011_y/feb/fri[4]);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decade);
+       CPP14_ASSERT((copy(ym) -= one_decade) == 1991_y/feb/fri[4]);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decade);
+
+       CPP14_ASSERT(ym + one_decamonth == 2001_y/dec/fri[4]);
+       NOEXCEPT_CONVERSION(ym + one_decamonth);
+       CPP14_ASSERT(one_decamonth + ym  == 2001_y/dec/fri[4]);
+       NOEXCEPT_CONVERSION(one_decamonth + ym);
+       CPP14_ASSERT(ym - one_decamonth == 2000_y/apr/fri[4]);
+       NOEXCEPT_CONVERSION(ym - one_decamonth);
+       CPP14_ASSERT((copy(ym) += one_decamonth) == 2001_y/dec/fri[4]);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decamonth);
+       CPP14_ASSERT((copy(ym) -= one_decamonth) == 2000_y/apr/fri[4]);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decamonth);
+
+       CPP14_ASSERT(ym + custom_month == 2001_y/mar/fri[4]);
+       NOEXCEPT_ASSERT(ym + custom_month);
+       CPP14_ASSERT(custom_month + ym == 2001_y/mar/fri[4]);
+       NOEXCEPT_ASSERT(custom_month + ym);
+       CPP14_ASSERT(ym - custom_month == 2001_y/jan/fri[4]);
+       NOEXCEPT_ASSERT(ym - custom_month);
+       CPP14_ASSERT((copy(ym) += custom_month) == 2001_y/mar/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) += custom_month);
+       CPP14_ASSERT((copy(ym) -= custom_month) == 2001_y/jan/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_month);
+      
+       CPP11_ASSERT(ym + custom_year == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(ym + custom_year);
+       CPP11_ASSERT(custom_year + ym == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(custom_year + ym);
+       CPP11_ASSERT(ym - custom_year == 2000_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(ym - custom_year);
+       CPP14_ASSERT((copy(ym) += custom_year) == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) += custom_year);
+       CPP14_ASSERT((copy(ym) -= custom_year) == 2000_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_year);
+
+       CPP11_ASSERT(ym + prefer_year == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(ym + prefer_year);
+       CPP11_ASSERT(prefer_year + ym == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(prefer_year + ym);
+       CPP11_ASSERT(ym - prefer_year == 2000_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(ym - prefer_year);
+       CPP14_ASSERT((copy(ym) += prefer_year) == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) += prefer_year);
+       CPP14_ASSERT((copy(ym) -= prefer_year) == 2000_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) -= prefer_year);
+    }
+
+    {
+       constexpr year_month_weekday_last ym = 2001_y/feb/fri[last];
+       CPP14_ASSERT(ym + one_month == 2001_y/mar/fri[last]);
+       NOEXCEPT_ASSERT(ym + one_month);
+       CPP14_ASSERT(one_month + ym == 2001_y/mar/fri[last]);
+       NOEXCEPT_ASSERT(one_month + ym);
+       CPP14_ASSERT(ym - one_month == 2001_y/jan/fri[last]);
+       NOEXCEPT_ASSERT(ym - one_month);
+       CPP14_ASSERT((copy(ym) += one_month) == 2001_y/mar/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) += one_month);
+       CPP14_ASSERT((copy(ym) -= one_month) == 2001_y/jan/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) -= one_month);
+      
+       CPP11_ASSERT(ym + one_year == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(ym + one_year);
+       CPP11_ASSERT(one_year + ym == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(one_year + ym);
+       CPP11_ASSERT(ym - one_year == 2000_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(ym - one_year);
+       CPP14_ASSERT((copy(ym) += one_year) == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) += one_year);
+       CPP14_ASSERT((copy(ym) -= one_year) == 2000_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) -= one_year);
+
+       CPP11_ASSERT(ym + one_decade == 2011_y/feb/fri[last]);
+       NOEXCEPT_CONVERSION(ym + one_decade);
+       CPP11_ASSERT(one_decade + ym == 2011_y/feb/fri[last]);
+       NOEXCEPT_CONVERSION(one_decade + ym);
+       CPP11_ASSERT(ym - one_decade == 1991_y/feb/fri[last]);
+       NOEXCEPT_CONVERSION(ym - one_decade);
+       CPP14_ASSERT((copy(ym) += one_decade) == 2011_y/feb/fri[last]);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decade);
+       CPP14_ASSERT((copy(ym) -= one_decade) == 1991_y/feb/fri[last]);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decade);
+
+       CPP14_ASSERT(ym + one_decamonth == 2001_y/dec/fri[last]);
+       NOEXCEPT_CONVERSION(ym + one_decamonth);
+       CPP14_ASSERT(one_decamonth + ym  == 2001_y/dec/fri[last]);
+       NOEXCEPT_CONVERSION(one_decamonth + ym);
+       CPP14_ASSERT(ym - one_decamonth == 2000_y/apr/fri[last]);
+       NOEXCEPT_CONVERSION(ym - one_decamonth);
+       CPP14_ASSERT((copy(ym) += one_decamonth) == 2001_y/dec/fri[last]);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decamonth);
+       CPP14_ASSERT((copy(ym) -= one_decamonth) == 2000_y/apr/fri[last]);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decamonth);
+
+       CPP14_ASSERT(ym + custom_month == 2001_y/mar/fri[last]);
+       NOEXCEPT_ASSERT(ym + custom_month);
+       CPP14_ASSERT(custom_month + ym == 2001_y/mar/fri[last]);
+       NOEXCEPT_ASSERT(custom_month + ym);
+       CPP14_ASSERT(ym - custom_month == 2001_y/jan/fri[last]);
+       NOEXCEPT_ASSERT(ym - custom_month);
+       CPP14_ASSERT((copy(ym) += custom_month) == 2001_y/mar/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) += custom_month);
+       CPP14_ASSERT((copy(ym) -= custom_month) == 2001_y/jan/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_month);
+      
+       CPP11_ASSERT(ym + custom_year == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(ym + custom_year);
+       CPP11_ASSERT(custom_year + ym == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(custom_year + ym);
+       CPP11_ASSERT(ym - custom_year == 2000_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(ym - custom_year);
+       CPP14_ASSERT((copy(ym) += custom_year) == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) += custom_year);
+       CPP14_ASSERT((copy(ym) -= custom_year) == 2000_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_year);
+
+       CPP11_ASSERT(ym + prefer_year == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(ym + prefer_year);
+       CPP11_ASSERT(prefer_year + ym == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(prefer_year + ym);
+       CPP11_ASSERT(ym - prefer_year == 2000_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(ym - prefer_year);
+       CPP14_ASSERT((copy(ym) += prefer_year) == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) += prefer_year);
+       CPP14_ASSERT((copy(ym) -= prefer_year) == 2000_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) -= prefer_year);
+    }
+}

test/date_test/op_div_day_day.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 // day / day not allowed
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_int_month.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 // int / month not allowed
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_int_year.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 // int / year not allowed
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_last_last.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 // last / last not allowed
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_month_day.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/op_div_month_day_last.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -24,7 +24,7 @@
 // constexpr month_day_last operator/(int   m, last_spec) noexcept;
 // constexpr month_day_last operator/(last_spec, const month& m) noexcept;
 // constexpr month_day_last operator/(last_spec, int   m) noexcept;
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_month_day_month_day.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 // month_day / month_day not allowed
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_month_month.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 // month / month not allowed
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_month_weekday.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/op_div_month_weekday_last.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/op_div_month_year.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 // month / year not allowed
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_survey.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -42,7 +42,7 @@ main()
 {
     using std::is_same;
     using namespace date;
-    
+
     static_assert(is_same<decltype(test(        1,         1,         1)), int>{}, "");
     static_assert(is_same<decltype(test(        1,         1,       1_d)), month_day>{}, "");
     static_assert(is_same<decltype(test(        1,         1,       jan)), void>{}, "");
@@ -50,7 +50,7 @@ main()
     static_assert(is_same<decltype(test(        1,         1,      last)), month_day_last>{}, "");
     static_assert(is_same<decltype(test(        1,         1,    sun[1])), month_weekday>{}, "");
     static_assert(is_same<decltype(test(        1,         1, sun[last])), month_weekday_last>{}, "");
-    
+
     static_assert(is_same<decltype(test(        1,       1_d,         1)), year_month_day>{}, "");
     static_assert(is_same<decltype(test(        1,       1_d,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(        1,       1_d,       jan)), void>{}, "");
@@ -58,7 +58,7 @@ main()
     static_assert(is_same<decltype(test(        1,       1_d,      last)), void>{}, "");
     static_assert(is_same<decltype(test(        1,       1_d,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(        1,       1_d, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(        1,       jan,         1)), void>{}, "");
     static_assert(is_same<decltype(test(        1,       jan,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(        1,       jan,       jan)), void>{}, "");
@@ -66,7 +66,7 @@ main()
     static_assert(is_same<decltype(test(        1,       jan,      last)), void>{}, "");
     static_assert(is_same<decltype(test(        1,       jan,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(        1,       jan, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(        1,       1_y,         1)), void>{}, "");
     static_assert(is_same<decltype(test(        1,       1_y,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(        1,       1_y,       jan)), void>{}, "");
@@ -74,7 +74,7 @@ main()
     static_assert(is_same<decltype(test(        1,       1_y,      last)), void>{}, "");
     static_assert(is_same<decltype(test(        1,       1_y,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(        1,       1_y, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(        1,      last,         1)), year_month_day_last>{}, "");
     static_assert(is_same<decltype(test(        1,      last,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(        1,      last,       jan)), void>{}, "");
@@ -82,7 +82,7 @@ main()
     static_assert(is_same<decltype(test(        1,      last,      last)), void>{}, "");
     static_assert(is_same<decltype(test(        1,      last,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(        1,      last, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(        1,    sun[1],         1)), year_month_weekday>{}, "");
     static_assert(is_same<decltype(test(        1,    sun[1],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(        1,    sun[1],       jan)), void>{}, "");
@@ -90,7 +90,7 @@ main()
     static_assert(is_same<decltype(test(        1,    sun[1],      last)), void>{}, "");
     static_assert(is_same<decltype(test(        1,    sun[1],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(        1,    sun[1], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(        1, sun[last],         1)), year_month_weekday_last>{}, "");
     static_assert(is_same<decltype(test(        1, sun[last],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(        1, sun[last],       jan)), void>{}, "");
@@ -98,7 +98,7 @@ main()
     static_assert(is_same<decltype(test(        1, sun[last],      last)), void>{}, "");
     static_assert(is_same<decltype(test(        1, sun[last],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(        1, sun[last], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_d,         1,         1)), year_month_day>{}, "");
     static_assert(is_same<decltype(test(      1_d,         1,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,         1,       jan)), void>{}, "");
@@ -106,7 +106,7 @@ main()
     static_assert(is_same<decltype(test(      1_d,         1,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,         1,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,         1, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_d,       1_d,         1)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,       1_d,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,       1_d,       jan)), void>{}, "");
@@ -114,7 +114,7 @@ main()
     static_assert(is_same<decltype(test(      1_d,       1_d,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,       1_d,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,       1_d, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_d,       jan,         1)), year_month_day>{}, "");
     static_assert(is_same<decltype(test(      1_d,       jan,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,       jan,       jan)), void>{}, "");
@@ -122,7 +122,7 @@ main()
     static_assert(is_same<decltype(test(      1_d,       jan,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,       jan,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,       jan, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_d,       1_y,         1)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,       1_y,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,       1_y,       jan)), void>{}, "");
@@ -130,7 +130,7 @@ main()
     static_assert(is_same<decltype(test(      1_d,       1_y,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,       1_y,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,       1_y, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_d,      last,         1)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,      last,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,      last,       jan)), void>{}, "");
@@ -138,7 +138,7 @@ main()
     static_assert(is_same<decltype(test(      1_d,      last,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,      last,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,      last, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_d,    sun[1],         1)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,    sun[1],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,    sun[1],       jan)), void>{}, "");
@@ -146,7 +146,7 @@ main()
     static_assert(is_same<decltype(test(      1_d,    sun[1],      last)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,    sun[1],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      1_d,    sun[1], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_d, sun[last],         1)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d, sun[last],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d, sun[last],       jan)), void>{}, "");
@@ -154,7 +154,7 @@ main()
     static_assert(is_same<decltype(test(      1_d, sun[last],      last)), void>{}, "");
     static_assert(is_same<decltype(test(      1_d, sun[last],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      1_d, sun[last], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      jan,         1,         1)), year_month_day>{}, "");
     static_assert(is_same<decltype(test(      jan,         1,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,         1,       jan)), void>{}, "");
@@ -162,7 +162,7 @@ main()
     static_assert(is_same<decltype(test(      jan,         1,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,         1,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      jan,         1, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      jan,       1_d,         1)), year_month_day>{}, "");
     static_assert(is_same<decltype(test(      jan,       1_d,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,       1_d,       jan)), void>{}, "");
@@ -170,7 +170,7 @@ main()
     static_assert(is_same<decltype(test(      jan,       1_d,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,       1_d,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      jan,       1_d, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      jan,       jan,         1)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,       jan,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,       jan,       jan)), void>{}, "");
@@ -178,7 +178,7 @@ main()
     static_assert(is_same<decltype(test(      jan,       jan,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,       jan,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      jan,       jan, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      jan,       1_y,         1)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,       1_y,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,       1_y,       jan)), void>{}, "");
@@ -186,7 +186,7 @@ main()
     static_assert(is_same<decltype(test(      jan,       1_y,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,       1_y,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      jan,       1_y, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      jan,      last,         1)), year_month_day_last>{}, "");
     static_assert(is_same<decltype(test(      jan,      last,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,      last,       jan)), void>{}, "");
@@ -194,7 +194,7 @@ main()
     static_assert(is_same<decltype(test(      jan,      last,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,      last,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      jan,      last, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      jan,    sun[1],         1)), year_month_weekday>{}, "");
     static_assert(is_same<decltype(test(      jan,    sun[1],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,    sun[1],       jan)), void>{}, "");
@@ -202,7 +202,7 @@ main()
     static_assert(is_same<decltype(test(      jan,    sun[1],      last)), void>{}, "");
     static_assert(is_same<decltype(test(      jan,    sun[1],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      jan,    sun[1], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      jan, sun[last],         1)), year_month_weekday_last>{}, "");
     static_assert(is_same<decltype(test(      jan, sun[last],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      jan, sun[last],       jan)), void>{}, "");
@@ -210,7 +210,7 @@ main()
     static_assert(is_same<decltype(test(      jan, sun[last],      last)), void>{}, "");
     static_assert(is_same<decltype(test(      jan, sun[last],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      jan, sun[last], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_y,         1,         1)), year_month_day>{}, "");
     static_assert(is_same<decltype(test(      1_y,         1,       1_d)), year_month_day>{}, "");
     static_assert(is_same<decltype(test(      1_y,         1,       jan)), void>{}, "");
@@ -218,7 +218,7 @@ main()
     static_assert(is_same<decltype(test(      1_y,         1,      last)), year_month_day_last>{}, "");
     static_assert(is_same<decltype(test(      1_y,         1,    sun[1])), year_month_weekday>{}, "");
     static_assert(is_same<decltype(test(      1_y,         1, sun[last])), year_month_weekday_last>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_y,       1_d,         1)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,       1_d,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,       1_d,       jan)), void>{}, "");
@@ -226,7 +226,7 @@ main()
     static_assert(is_same<decltype(test(      1_y,       1_d,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,       1_d,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,       1_d, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_y,       jan,         1)), year_month_day>{}, "");
     static_assert(is_same<decltype(test(      1_y,       jan,       1_d)), year_month_day>{}, "");
     static_assert(is_same<decltype(test(      1_y,       jan,       jan)), void>{}, "");
@@ -234,7 +234,7 @@ main()
     static_assert(is_same<decltype(test(      1_y,       jan,      last)), year_month_day_last>{}, "");
     static_assert(is_same<decltype(test(      1_y,       jan,    sun[1])), year_month_weekday>{}, "");
     static_assert(is_same<decltype(test(      1_y,       jan, sun[last])), year_month_weekday_last>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_y,       1_y,         1)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,       1_y,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,       1_y,       jan)), void>{}, "");
@@ -242,7 +242,7 @@ main()
     static_assert(is_same<decltype(test(      1_y,       1_y,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,       1_y,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,       1_y, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_y,      last,         1)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,      last,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,      last,       jan)), void>{}, "");
@@ -250,7 +250,7 @@ main()
     static_assert(is_same<decltype(test(      1_y,      last,      last)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,      last,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,      last, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_y,    sun[1],         1)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,    sun[1],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,    sun[1],       jan)), void>{}, "");
@@ -258,7 +258,7 @@ main()
     static_assert(is_same<decltype(test(      1_y,    sun[1],      last)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,    sun[1],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      1_y,    sun[1], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(      1_y, sun[last],         1)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y, sun[last],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y, sun[last],       jan)), void>{}, "");
@@ -266,7 +266,7 @@ main()
     static_assert(is_same<decltype(test(      1_y, sun[last],      last)), void>{}, "");
     static_assert(is_same<decltype(test(      1_y, sun[last],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(      1_y, sun[last], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(     last,         1,         1)), year_month_day_last>{}, "");
     static_assert(is_same<decltype(test(     last,         1,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(     last,         1,       jan)), void>{}, "");
@@ -274,7 +274,7 @@ main()
     static_assert(is_same<decltype(test(     last,         1,      last)), void>{}, "");
     static_assert(is_same<decltype(test(     last,         1,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(     last,         1, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(     last,       1_d,         1)), void>{}, "");
     static_assert(is_same<decltype(test(     last,       1_d,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(     last,       1_d,       jan)), void>{}, "");
@@ -282,7 +282,7 @@ main()
     static_assert(is_same<decltype(test(     last,       1_d,      last)), void>{}, "");
     static_assert(is_same<decltype(test(     last,       1_d,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(     last,       1_d, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(     last,       jan,         1)), year_month_day_last>{}, "");
     static_assert(is_same<decltype(test(     last,       jan,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(     last,       jan,       jan)), void>{}, "");
@@ -290,7 +290,7 @@ main()
     static_assert(is_same<decltype(test(     last,       jan,      last)), void>{}, "");
     static_assert(is_same<decltype(test(     last,       jan,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(     last,       jan, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(     last,       1_y,         1)), void>{}, "");
     static_assert(is_same<decltype(test(     last,       1_y,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(     last,       1_y,       jan)), void>{}, "");
@@ -298,7 +298,7 @@ main()
     static_assert(is_same<decltype(test(     last,       1_y,      last)), void>{}, "");
     static_assert(is_same<decltype(test(     last,       1_y,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(     last,       1_y, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(     last,      last,         1)), void>{}, "");
     static_assert(is_same<decltype(test(     last,      last,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(     last,      last,       jan)), void>{}, "");
@@ -306,7 +306,7 @@ main()
     static_assert(is_same<decltype(test(     last,      last,      last)), void>{}, "");
     static_assert(is_same<decltype(test(     last,      last,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(     last,      last, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(     last,    sun[1],         1)), void>{}, "");
     static_assert(is_same<decltype(test(     last,    sun[1],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(     last,    sun[1],       jan)), void>{}, "");
@@ -314,7 +314,7 @@ main()
     static_assert(is_same<decltype(test(     last,    sun[1],      last)), void>{}, "");
     static_assert(is_same<decltype(test(     last,    sun[1],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(     last,    sun[1], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(     last, sun[last],         1)), void>{}, "");
     static_assert(is_same<decltype(test(     last, sun[last],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(     last, sun[last],       jan)), void>{}, "");
@@ -322,7 +322,7 @@ main()
     static_assert(is_same<decltype(test(     last, sun[last],      last)), void>{}, "");
     static_assert(is_same<decltype(test(     last, sun[last],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(     last, sun[last], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(   sun[1],         1,         1)), year_month_weekday>{}, "");
     static_assert(is_same<decltype(test(   sun[1],         1,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],         1,       jan)), void>{}, "");
@@ -330,7 +330,7 @@ main()
     static_assert(is_same<decltype(test(   sun[1],         1,      last)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],         1,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],         1, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(   sun[1],       1_d,         1)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],       1_d,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],       1_d,       jan)), void>{}, "");
@@ -338,7 +338,7 @@ main()
     static_assert(is_same<decltype(test(   sun[1],       1_d,      last)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],       1_d,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],       1_d, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(   sun[1],       jan,         1)), year_month_weekday>{}, "");
     static_assert(is_same<decltype(test(   sun[1],       jan,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],       jan,       jan)), void>{}, "");
@@ -346,7 +346,7 @@ main()
     static_assert(is_same<decltype(test(   sun[1],       jan,      last)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],       jan,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],       jan, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(   sun[1],       1_y,         1)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],       1_y,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],       1_y,       jan)), void>{}, "");
@@ -354,7 +354,7 @@ main()
     static_assert(is_same<decltype(test(   sun[1],       1_y,      last)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],       1_y,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],       1_y, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(   sun[1],      last,         1)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],      last,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],      last,       jan)), void>{}, "");
@@ -362,7 +362,7 @@ main()
     static_assert(is_same<decltype(test(   sun[1],      last,      last)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],      last,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],      last, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(   sun[1],    sun[1],         1)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],    sun[1],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],    sun[1],       jan)), void>{}, "");
@@ -370,7 +370,7 @@ main()
     static_assert(is_same<decltype(test(   sun[1],    sun[1],      last)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],    sun[1],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1],    sun[1], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(   sun[1], sun[last],         1)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1], sun[last],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1], sun[last],       jan)), void>{}, "");
@@ -378,7 +378,7 @@ main()
     static_assert(is_same<decltype(test(   sun[1], sun[last],      last)), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1], sun[last],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(   sun[1], sun[last], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(sun[last],         1,         1)), year_month_weekday_last>{}, "");
     static_assert(is_same<decltype(test(sun[last],         1,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],         1,       jan)), void>{}, "");
@@ -386,7 +386,7 @@ main()
     static_assert(is_same<decltype(test(sun[last],         1,      last)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],         1,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],         1, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(sun[last],       1_d,         1)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],       1_d,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],       1_d,       jan)), void>{}, "");
@@ -394,7 +394,7 @@ main()
     static_assert(is_same<decltype(test(sun[last],       1_d,      last)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],       1_d,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],       1_d, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(sun[last],       jan,         1)), year_month_weekday_last>{}, "");
     static_assert(is_same<decltype(test(sun[last],       jan,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],       jan,       jan)), void>{}, "");
@@ -402,7 +402,7 @@ main()
     static_assert(is_same<decltype(test(sun[last],       jan,      last)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],       jan,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],       jan, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(sun[last],       1_y,         1)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],       1_y,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],       1_y,       jan)), void>{}, "");
@@ -410,7 +410,7 @@ main()
     static_assert(is_same<decltype(test(sun[last],       1_y,      last)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],       1_y,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],       1_y, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(sun[last],      last,         1)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],      last,       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],      last,       jan)), void>{}, "");
@@ -418,7 +418,7 @@ main()
     static_assert(is_same<decltype(test(sun[last],      last,      last)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],      last,    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],      last, sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(sun[last],    sun[1],         1)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],    sun[1],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],    sun[1],       jan)), void>{}, "");
@@ -426,7 +426,7 @@ main()
     static_assert(is_same<decltype(test(sun[last],    sun[1],      last)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],    sun[1],    sun[1])), void>{}, "");
     static_assert(is_same<decltype(test(sun[last],    sun[1], sun[last])), void>{}, "");
-    
+
     static_assert(is_same<decltype(test(sun[last], sun[last],         1)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last], sun[last],       1_d)), void>{}, "");
     static_assert(is_same<decltype(test(sun[last], sun[last],       jan)), void>{}, "");

test/date_test/op_div_weekday_indexed_weekday_indexed.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 // weekday_indexed / weekday_indexed not allowed
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_weekday_last_weekday_last.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 // weekday_last / weekday_last not allowed
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_year_month.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -22,7 +22,7 @@
 
 // constexpr year_month operator/(const year& y, const month& m) noexcept;
 // constexpr year_month operator/(const year& y, int   m) noexcept;
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_year_month_day.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/op_div_year_month_day_last.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -25,7 +25,7 @@
 // constexpr year_month_day_last operator/(int y, const month_day_last& mdl) noexcept;
 // constexpr year_month_day_last operator/(const month_day_last& mdl, const year& y) noexcept;
 // constexpr year_month_day_last operator/(const month_day_last& mdl, int y) noexcept;
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_year_month_weekday.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/op_div_year_month_weekday_last.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/op_div_year_month_year_month.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 // year_month / year_month not allowed
- 
+
 #include "date.h"
 
 int

test/date_test/op_div_year_year.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -21,7 +21,7 @@
 // SOFTWARE.
 
 // year / year not allowed
- 
+
 #include "date.h"
 
 int

test/date_test/parse.pass.cpp

@@ -0,0 +1,906 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+// This test is meant to maintain a record of the sizeof each type.
+
+#include "date.h"
+#include <cassert>
+#include <sstream>
+
+void
+test_a()
+{
+    using namespace date;
+    {
+        // correct abbreviation
+        std::istringstream in{"Sun 2016-12-11"};
+        sys_days tp;
+        in >> parse("%a %F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct abbreviation
+        std::istringstream in{"Sun 2016-12-11"};
+        sys_days tp;
+        in >> parse("%A %F", tp);
+        // this may fail with libstdc++, see https://github.com/HowardHinnant/date/issues/388
+        // possible workaround: compile date.h with -DONLY_C_LOCALE=1
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct full name
+        std::istringstream in{"Sunday 2016-12-11"};
+        sys_days tp;
+        in >> parse("%a %F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct full name
+        std::istringstream in{"Sunday 2016-12-11"};
+        sys_days tp;
+        in >> parse("%A %F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // not a valid name
+        std::istringstream in{"Dec 2016-12-11"};
+        sys_days tp;
+        in >> parse("%a %F", tp);
+        assert( in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 1970_y/1/1);
+    }
+    {
+        // wrong name
+        std::istringstream in{"Sat 2016-12-11"};
+        sys_days tp;
+        in >> parse("%a %F", tp);
+        assert( in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 1970_y/1/1);
+    }
+    {
+        // extra ws in input
+        std::istringstream in{"Sun  2016-12-11"};
+        sys_days tp;
+        in >> parse("%a %F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // extra ws in format
+        std::istringstream in{"Sun 2016-12-11"};
+        sys_days tp;
+        in >> parse("%a  %F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+}
+
+void
+test_b()
+{
+    using namespace date;
+    {
+        // correct abbreviation
+        std::istringstream in{"Dec 11 2016"};
+        sys_days tp;
+        in >> parse("%b %d %Y", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct abbreviation
+        std::istringstream in{"Dec 11 2016"};
+        sys_days tp;
+        in >> parse("%B %d %Y", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct abbreviation
+        std::istringstream in{"Dec 11 2016"};
+        sys_days tp;
+        in >> parse("%h %d %Y", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct full name
+        std::istringstream in{"December 11 2016"};
+        sys_days tp;
+        in >> parse("%b %d %Y", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct full name
+        std::istringstream in{"December 11 2016"};
+        sys_days tp;
+        in >> parse("%B %d %Y", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct full name
+        std::istringstream in{"December 11 2016"};
+        sys_days tp;
+        in >> parse("%h %d %Y", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // incorrect abbreviation
+        std::istringstream in{"Dece 11 2016"};
+        sys_days tp;
+        in >> parse("%b %d %Y", tp);
+        assert( in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 1970_y/1/1);
+    }
+}
+
+void
+test_c()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        // correct abbreviation
+        std::istringstream in{"Sun Dec 11 14:02:43 2016"};
+        sys_seconds tp;
+        in >> parse("%c", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{14} + minutes{2} + seconds{43});
+    }
+}
+
+void
+test_x()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        // correct abbreviation
+        std::istringstream in{"12/11/16"};
+        sys_seconds tp;
+        in >> parse("%x", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11});
+    }
+}
+
+void
+test_X()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        // correct abbreviation
+        std::istringstream in{"2016-12-11 14:02:43"};
+        sys_seconds tp;
+        in >> parse("%F %X", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{14} + minutes{2} + seconds{43});
+    }
+}
+
+void
+test_C()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"20 16 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        std::istringstream in{"-2 1 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == -101_y/12/11);
+    }
+    {
+        std::istringstream in{"-1 0 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == -100_y/12/11);
+    }
+    {
+        std::istringstream in{"-1 99 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == -99_y/12/11);
+    }
+    {
+        std::istringstream in{"-1 1 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == -1_y/12/11);
+    }
+    {
+        std::istringstream in{"0 0 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 0_y/12/11);
+    }
+    {
+        std::istringstream in{"0 1 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 1_y/12/11);
+    }
+    {
+        std::istringstream in{"0 99 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 99_y/12/11);
+    }
+    {
+        std::istringstream in{"1 0 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 100_y/12/11);
+    }
+    {
+        std::istringstream in{"1 1 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 101_y/12/11);
+    }
+}
+
+void
+test_d()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016 09 12"};
+        sys_days tp;
+        in >> parse("%Y %d %m", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/9);
+    }
+    {
+        std::istringstream in{"2016 09 12"};
+        sys_days tp;
+        in >> parse("%Y %e %m", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/9);
+    }
+    {
+        std::istringstream in{"2016 9 12"};
+        sys_days tp;
+        in >> parse("%Y %d %m", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/9);
+    }
+    {
+        std::istringstream in{"2016 9 12"};
+        sys_days tp;
+        in >> parse("%Y %e %m", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/9);
+    }
+    {
+        std::istringstream in{"2016 31 11"};
+        sys_days tp;
+        in >> parse("%Y %e %m", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_D()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"12/11/16"};
+        sys_days tp;
+        in >> parse("%D", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/11);
+    }
+}
+
+void
+test_F()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-13"};
+        sys_days tp;
+        in >> parse("%F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/13);
+    }
+    {
+        std::istringstream in{"2016-12-13"};
+        year_month_day tp;
+        in >> parse("%F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/13);
+    }
+}
+
+void
+test_H()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-11 15"};
+        sys_time<hours> tp;
+        in >> parse("%F %H", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{15});
+    }
+    {
+        std::istringstream in{"2016-12-11 24"};
+        sys_time<hours> tp;
+        in >> parse("%F %H", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_Ip()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-11 1 pm"};
+        sys_time<hours> tp;
+        in >> parse("%F %I %p", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{13});
+    }
+    {
+        std::istringstream in{"2016-12-11 1 am"};
+        sys_time<hours> tp;
+        in >> parse("%F %I %p", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{1});
+    }
+    {
+        std::istringstream in{"2016-12-11 13 am"};
+        sys_time<hours> tp;
+        in >> parse("%F %I %p", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_j()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016 361"};
+        sys_days tp;
+        in >> parse("%Y %j", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+}
+
+void
+test_m()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016 12 09"};
+        sys_days tp;
+        in >> parse("%Y %d %m", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/9/12);
+    }
+    {
+        std::istringstream in{"2016 12 9"};
+        sys_days tp;
+        in >> parse("%Y %d %m", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/9/12);
+    }
+    {
+        std::istringstream in{"2016 12 13"};
+        sys_days tp;
+        in >> parse("%Y %d %m", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_M()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-11 15"};
+        sys_time<minutes> tp;
+        in >> parse("%F %M", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + minutes{15});
+    }
+    {
+        std::istringstream in{"2016-12-11 65"};
+        sys_time<minutes> tp;
+        in >> parse("%F %M", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_S()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-11 15"};
+        sys_seconds tp;
+        in >> parse("%F %S", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + seconds{15});
+    }
+    {
+        std::istringstream in{"2016-12-11 15.001"};
+        sys_time<milliseconds> tp;
+        in >> parse("%F %S", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + seconds{15} + milliseconds{1});
+    }
+    {
+        std::istringstream in{"2016-12-11 60"};
+        sys_seconds tp;
+        in >> parse("%F %S", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_T()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-11 15:43:22"};
+        sys_seconds tp;
+        in >> parse("%F %T", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{15} + minutes{43} + seconds{22});
+    }
+    {
+        std::istringstream in{"2016-12-11 15:43:22.001"};
+        sys_time<milliseconds> tp;
+        in >> parse("%F %T", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{15} + minutes{43} + seconds{22} +
+                                              milliseconds{1});
+    }
+    {
+        std::istringstream in{"2016-12-11 15:43:22"};
+        sys_time<milliseconds> tp;
+        in >> parse("%F %T", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{15} + minutes{43} + seconds{22});
+    }
+    {
+        std::istringstream in{"15:43:22.001"};
+        milliseconds d;
+        in >> parse("%T", d);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(d == hours{15} + minutes{43} + seconds{22} + milliseconds{1});
+    }
+    {
+        std::istringstream in{"2016-12-11 24:43:22"};
+        sys_seconds tp;
+        in >> parse("%F %T", tp);
+        assert(in.fail());
+    }
+    {
+        std::istringstream in{"2016-12-11 15:60:22"};
+        sys_seconds tp;
+        in >> parse("%F %T", tp);
+        assert(in.fail());
+    }
+    {
+        std::istringstream in{"2016-12-11 15:43:60"};
+        sys_seconds tp;
+        in >> parse("%F %T", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_p()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-11 11pm"};
+        sys_time<hours> tp;
+        in >> parse("%F %I%p", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{23});
+    }
+}
+
+void
+test_r()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-26 1:36:57 pm"};
+        sys_seconds tp;
+        in >> parse("%F %r", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26} + hours{13} + minutes{36} + seconds{57});
+    }
+}
+
+void
+test_R()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-26 13:36"};
+        sys_seconds tp;
+        in >> parse("%F %R", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26} + hours{13} + minutes{36});
+    }
+}
+
+void
+test_U()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-52-1"};
+        sys_days tp;
+        in >> parse("%Y-%U-%w", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+}
+
+void
+test_W()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-52-1"};
+        sys_days tp;
+        in >> parse("%Y-%W-%w", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+}
+
+void
+test_GV()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-52-1"};
+        sys_days tp;
+        in >> parse("%G-%V-%w", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+    {
+        std::istringstream in{"2016-52-1"};
+        sys_days tp;
+        in >> parse("%G-%V-%w", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+    {
+        std::istringstream in{"20 16-52-1"};
+        sys_days tp;
+        in >> parse("%C %g-%V-%w", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+    {
+        std::istringstream in{"20 16-52-1"};
+        sys_days tp;
+        in >> parse("%C %g-%V-%u", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+}
+
+void
+test_z()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-26 15:53:22 -0500"};
+        sys_seconds tp;
+        in >> parse("%F %T %z", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26} + hours{20} + minutes{53} + seconds{22});
+    }
+    {
+        std::istringstream in{"2016-12-26 15:53:22 -0500"};
+        local_seconds tp;
+        in >> parse("%F %T %z", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == local_days{2016_y/12/26} + hours{15} + minutes{53} + seconds{22});
+    }
+    {
+        std::istringstream in{"2016-12-26 15:53:22 -05:00"};
+        sys_seconds tp;
+        in >> parse("%F %T %Ez", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26} + hours{20} + minutes{53} + seconds{22});
+    }
+}
+
+void
+test_Z()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::string a;
+        std::istringstream in{"2016-12-26 15:53:22 word"};
+        local_seconds tp;
+        in >> parse("%F %T %Z", tp, a);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == local_days{2016_y/12/26} + hours{15} + minutes{53} + seconds{22});
+        assert(a == "word");
+    }
+}
+
+void
+test_trailing_Z()
+{
+    std::string format = "%FT%TZ";
+    std::string datetime = "2017-2-15T13:13:13";
+    std::istringstream input(datetime);
+    date::sys_seconds tp;
+    input >> date::parse(format, tp);
+    assert(input.fail());
+    assert(input.eof());
+}
+
+void
+test_leading_ws()
+{
+    using namespace std;
+    using namespace date;
+    istringstream in{"05/04/17 5/4/17"};
+    year_month_day d1, d2;
+    in >> parse("%D", d1) >> parse("%n%D", d2);
+    assert(d1 == may/4/2017);
+    assert(d2 == may/4/2017);
+}
+
+void
+test_space()
+{
+    using namespace std;
+    using namespace date;
+    {
+        istringstream in{"05/04/17"};
+        year_month_day d1;
+        in >> parse(" %D", d1);
+        assert(d1 == may/4/2017);
+    }
+    {
+        istringstream in{" 05/04/17"};
+        year_month_day d1;
+        in >> parse(" %D", d1);
+        assert(d1 == may/4/2017);
+    }
+    {
+        istringstream in{"  05/04/17"};
+        year_month_day d1;
+        in >> parse(" %D", d1);
+        assert(d1 == may/4/2017);
+    }
+}
+
+void
+test_n()
+{
+    using namespace std;
+    using namespace date;
+    {
+        istringstream in{"05/04/17"};
+        year_month_day d1;
+        in >> parse("%n%D", d1);
+        assert(in.fail());
+    }
+    {
+        istringstream in{" 05/04/17"};
+        year_month_day d1;
+        in >> parse("%n%D", d1);
+        assert(d1 == may/4/2017);
+    }
+    {
+        istringstream in{"  05/04/17"};
+        year_month_day d1;
+        in >> parse("%n%D", d1);
+        assert(in.fail());
+    }
+}
+
+void
+test_t()
+{
+    using namespace std;
+    using namespace date;
+    {
+        istringstream in{"05/04/17"};
+        year_month_day d1;
+        in >> parse("%t%D", d1);
+        assert(d1 == may/4/2017);
+    }
+    {
+        istringstream in{" 05/04/17"};
+        year_month_day d1;
+        in >> parse("%t%D", d1);
+        assert(d1 == may/4/2017);
+    }
+    {
+        istringstream in{"  05/04/17"};
+        year_month_day d1;
+        in >> parse("%t%D", d1);
+        assert(in.fail());
+    }
+}
+
+int
+main()
+{
+    test_a();
+    test_b();
+    test_c();
+    test_C();
+    test_d();
+    test_D();
+    test_F();
+    test_H();
+    test_Ip();
+    test_j();
+    test_m();
+    test_M();
+    test_p();
+    test_r();
+    test_R();
+    test_S();
+    test_T();
+    test_U();
+    test_W();
+    test_GV();
+    test_x();
+    test_X();
+    test_z();
+    test_Z();
+    test_trailing_Z();
+    test_leading_ws();
+    test_space();
+    test_n();
+    test_t();
+}

test/date_test/sizeof.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -34,7 +34,7 @@ main()
     static_assert(sizeof(months)                  == 4, "");
     static_assert(sizeof(years)                   == 4, "");
 
-    static_assert(sizeof(day_point)               == 4, "");
+    static_assert(sizeof(sys_days)               == 4, "");
 
     static_assert(sizeof(last_spec)               == 1, "");
 

test/date_test/time_of_day_hours.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -26,16 +26,16 @@
 // {
 // public:
 //     using precision = std::chrono::hours;
-// 
+//
 //     constexpr explicit time_of_day(std::chrono::hours since_midnight) noexcept;
 //     constexpr time_of_day(std::chrono::hours h, unsigned md) noexcept;
-// 
+//
 //     constexpr std::chrono::hours hours() const noexcept;
 //     constexpr unsigned mode() const noexcept;
-// 
+//
 //     constexpr explicit operator precision() const noexcept;
 //     constexpr precision to_duration() const noexcept;
-// 
+//
 //     void make24() noexcept;
 //     void make12() noexcept;
 // };
@@ -57,10 +57,10 @@ main()
 
     using tod = time_of_day<hours>;
 
-    static_assert(is_same<tod::precision, hours>{}, "");
+    static_assert(is_same<tod::precision::period, seconds::period>{}, "");
 
     static_assert( is_trivially_destructible<tod>{}, "");
-    static_assert(!is_default_constructible<tod>{}, "");
+    static_assert( is_default_constructible<tod>{}, "");
     static_assert( is_trivially_copy_constructible<tod>{}, "");
     static_assert( is_trivially_copy_assignable<tod>{}, "");
     static_assert( is_trivially_move_constructible<tod>{}, "");
@@ -68,14 +68,12 @@ main()
 
     static_assert(is_nothrow_constructible<tod, hours>{}, "");
     static_assert(!is_convertible<hours, tod>{}, "");
-    static_assert(is_nothrow_constructible<tod, hours, unsigned>{}, "");
 
     static_assert(is_nothrow_constructible<tod::precision, tod>{}, "");
     static_assert(!is_convertible<tod, tod::precision>{}, "");
 
     constexpr tod t1 = tod{hours{13}};
     static_assert(t1.hours() == hours{13}, "");
-    static_assert(t1.mode() == 0, "");
 #if __cplusplus >= 201402
     static_assert(static_cast<tod::precision>(t1) == hours{13}, "");
     static_assert(t1.to_duration() == hours{13}, "");
@@ -83,23 +81,14 @@ main()
 
     auto t2 = t1;
     assert(t2.hours() == t1.hours());
-    assert(t2.mode() == t1.mode());
     assert(t2.to_duration() == t1.to_duration());
     ostringstream os;
     os << t2;
-    assert(os.str() == "1300");
-    t2.make12();
+    assert(os.str() == "13:00:00");
+    auto h = make12(t2.hours());
     os.str("");
-    assert(t2.hours() == hours{1});
-    assert(t2.mode() == pm);
+    assert(h == hours{1});
     assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "1pm");
-    t2.make24();
-    os.str("");
-    assert(t2.hours() == hours{13});
-    assert(t2.mode() == 0);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "1300");
+    assert(!is_am(t2.hours()));
+    assert(is_pm(t2.hours()));
 }

test/date_test/time_of_day_microfortnights.pass.cpp

@@ -0,0 +1,111 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// 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.
+
+// enum {am = 1, pm};
+
+// template <class Rep, class Period>
+// class time_of_day<std::chrono::duration<Rep, Period>>
+// {
+// public:
+//     using precision = std::chrono::std::chrono::duration<Rep, Period>;
+//
+//     constexpr explicit time_of_day(precision since_midnight) noexcept;
+//     constexpr time_of_day(std::chrono::hours h, std::chrono::minutes m,
+//                           std::chrono::seconds s, precision sub_s,
+//                           unsigned md) noexcept;
+//
+//     constexpr std::chrono::hours hours() const noexcept;
+//     constexpr std::chrono::minutes minutes() const noexcept;
+//     constexpr std::chrono::seconds seconds() const noexcept;
+//     constexpr precision subseconds() const noexcept;
+//     constexpr unsigned mode() const noexcept;
+//
+//     constexpr explicit operator precision() const noexcept;
+//     constexpr precision to_duration() const noexcept;
+//
+//     void make24() noexcept;
+//     void make12() noexcept;
+// };
+
+// template <class Rep, class Period>
+// std::ostream&
+// operator<<(std::ostream& os, const time_of_day<std::chrono::duration<Rep, Period>>& t);
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+using fortnights = std::chrono::duration<date::weeks::rep,
+                                         date::detail::ratio_multiply<std::ratio<2>,
+                                                                      date::weeks::period>>;
+
+using microfortnights = std::chrono::duration<std::int64_t,
+                                              date::detail::ratio_multiply<fortnights::period,
+                                                                           std::micro>>;
+
+int
+main()
+{
+    using namespace date;
+    using namespace std;
+    using namespace std::chrono;
+
+    using tod = time_of_day<typename common_type<hours, minutes, microfortnights>::type>;
+
+    static_assert(is_same<tod::precision::period, ratio<1, 10000>>{}, "");
+
+    static_assert( is_trivially_destructible<tod>{}, "");
+    static_assert( is_default_constructible<tod>{}, "");
+    static_assert( is_trivially_copy_constructible<tod>{}, "");
+    static_assert( is_trivially_copy_assignable<tod>{}, "");
+    static_assert( is_trivially_move_constructible<tod>{}, "");
+    static_assert( is_trivially_move_assignable<tod>{}, "");
+
+    static_assert(is_constructible<tod, microfortnights>{}, "");
+    static_assert(!is_convertible<microfortnights, tod>{}, "");
+
+    static_assert(is_nothrow_constructible<tod::precision, tod>{}, "");
+    static_assert(!is_convertible<tod, tod::precision>{}, "");
+
+    constexpr tod t1 = tod{hours{13} + minutes{7} + microfortnights{5}};
+    static_assert(t1.hours() == hours{13}, "");
+    static_assert(t1.minutes() == minutes{7}, "");
+    static_assert(t1.seconds() == seconds{6}, "");
+    static_assert(t1.subseconds() == tod::precision{480}, "");
+#if __cplusplus >= 201402
+    static_assert(static_cast<tod::precision>(t1) == hours{13} + minutes{7}
+                                                     + microfortnights{5}, "");
+    static_assert(t1.to_duration() == hours{13} + minutes{7} + microfortnights{5}, "");
+#endif
+
+    auto t2 = t1;
+    assert(t2.hours() == t1.hours());
+    assert(t2.minutes() == t1.minutes());
+    assert(t2.seconds() == t1.seconds());
+    assert(t2.subseconds() == t1.subseconds());
+    assert(t2.to_duration() == t1.to_duration());
+    ostringstream os;
+    os << t2;
+    assert(os.str() == "13:07:06.0480");
+}

test/date_test/time_of_day_milliseconds.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -27,21 +27,21 @@
 // {
 // public:
 //     using precision = std::chrono::std::chrono::duration<Rep, Period>;
-// 
+//
 //     constexpr explicit time_of_day(precision since_midnight) noexcept;
 //     constexpr time_of_day(std::chrono::hours h, std::chrono::minutes m,
 //                           std::chrono::seconds s, precision sub_s,
 //                           unsigned md) noexcept;
-// 
+//
 //     constexpr std::chrono::hours hours() const noexcept;
 //     constexpr std::chrono::minutes minutes() const noexcept;
 //     constexpr std::chrono::seconds seconds() const noexcept;
 //     constexpr precision subseconds() const noexcept;
 //     constexpr unsigned mode() const noexcept;
-// 
+//
 //     constexpr explicit operator precision() const noexcept;
 //     constexpr precision to_duration() const noexcept;
-// 
+//
 //     void make24() noexcept;
 //     void make12() noexcept;
 // };
@@ -65,10 +65,10 @@ main()
 
     using tod = time_of_day<milliseconds>;
 
-    static_assert(is_same<tod::precision, milliseconds>{}, "");
+    static_assert(is_same<tod::precision::period, milliseconds::period>{}, "");
 
     static_assert( is_trivially_destructible<tod>{}, "");
-    static_assert(!is_default_constructible<tod>{}, "");
+    static_assert( is_default_constructible<tod>{}, "");
     static_assert( is_trivially_copy_constructible<tod>{}, "");
     static_assert( is_trivially_copy_assignable<tod>{}, "");
     static_assert( is_trivially_move_constructible<tod>{}, "");
@@ -76,8 +76,6 @@ main()
 
     static_assert(is_nothrow_constructible<tod, milliseconds>{}, "");
     static_assert(!is_convertible<milliseconds, tod>{}, "");
-    static_assert(is_nothrow_constructible<tod, hours, minutes, seconds, milliseconds,
-                                                unsigned>{}, "");
 
     static_assert(is_nothrow_constructible<tod::precision, tod>{}, "");
     static_assert(!is_convertible<tod, tod::precision>{}, "");
@@ -87,7 +85,6 @@ main()
     static_assert(t1.minutes() == minutes{7}, "");
     static_assert(t1.seconds() == seconds{5}, "");
     static_assert(t1.subseconds() == milliseconds{22}, "");
-    static_assert(t1.mode() == 0, "");
 #if __cplusplus >= 201402
     static_assert(static_cast<tod::precision>(t1) == hours{13} + minutes{7}
                                                      + seconds{5} + milliseconds{22}, "");
@@ -100,29 +97,8 @@ main()
     assert(t2.minutes() == t1.minutes());
     assert(t2.seconds() == t1.seconds());
     assert(t2.subseconds() == t1.subseconds());
-    assert(t2.mode() == t1.mode());
     assert(t2.to_duration() == t1.to_duration());
     ostringstream os;
     os << t2;
     assert(os.str() == "13:07:05.022");
-    t2.make12();
-    os.str("");
-    assert(t2.hours() == hours{1});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.seconds() == seconds{5});
-    assert(t2.subseconds() == milliseconds{22});
-    assert(t2.mode() == pm);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "1:07:05.022pm");
-    t2.make24();
-    os.str("");
-    assert(t2.hours() == hours{13});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.seconds() == seconds{5});
-    assert(t2.subseconds() == milliseconds{22});
-    assert(t2.mode() == 0);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "13:07:05.022");
 }

test/date_test/time_of_day_minutes.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -26,18 +26,18 @@
 // {
 // public:
 //     using precision = std::chrono::minutes;
-// 
+//
 //     constexpr explicit time_of_day(std::chrono::minutes since_midnight) noexcept;
 //     constexpr time_of_day(std::chrono::hours h, std::chrono::minutes m,
 //                           unsigned md) noexcept;
-// 
+//
 //     constexpr std::chrono::hours hours() const noexcept;
 //     constexpr std::chrono::minutes minutes() const noexcept;
 //     constexpr unsigned mode() const noexcept;
-// 
+//
 //     constexpr explicit operator precision() const noexcept;
 //     constexpr precision to_duration() const noexcept;
-// 
+//
 //     void make24() noexcept;
 //     void make12() noexcept;
 // };
@@ -59,10 +59,10 @@ main()
 
     using tod = time_of_day<minutes>;
 
-    static_assert(is_same<tod::precision, minutes>{}, "");
+    static_assert(is_same<tod::precision::period, seconds::period>{}, "");
 
     static_assert( is_trivially_destructible<tod>{}, "");
-    static_assert(!is_default_constructible<tod>{}, "");
+    static_assert( is_default_constructible<tod>{}, "");
     static_assert( is_trivially_copy_constructible<tod>{}, "");
     static_assert( is_trivially_copy_assignable<tod>{}, "");
     static_assert( is_trivially_move_constructible<tod>{}, "");
@@ -70,7 +70,6 @@ main()
 
     static_assert(is_nothrow_constructible<tod, minutes>{}, "");
     static_assert(!is_convertible<minutes, tod>{}, "");
-    static_assert(is_nothrow_constructible<tod, hours, minutes, unsigned>{}, "");
 
     static_assert(is_nothrow_constructible<tod::precision, tod>{}, "");
     static_assert(!is_convertible<tod, tod::precision>{}, "");
@@ -78,7 +77,6 @@ main()
     constexpr tod t1 = tod{hours{13} + minutes{7}};
     static_assert(t1.hours() == hours{13}, "");
     static_assert(t1.minutes() == minutes{7}, "");
-    static_assert(t1.mode() == 0, "");
 #if __cplusplus >= 201402
     static_assert(static_cast<tod::precision>(t1) == hours{13} + minutes{7}, "");
     static_assert(t1.to_duration() == hours{13} + minutes{7}, "");
@@ -87,25 +85,8 @@ main()
     auto t2 = t1;
     assert(t2.hours() == t1.hours());
     assert(t2.minutes() == t1.minutes());
-    assert(t2.mode() == t1.mode());
     assert(t2.to_duration() == t1.to_duration());
     ostringstream os;
     os << t2;
-    assert(os.str() == "13:07");
-    t2.make12();
-    os.str("");
-    assert(t2.hours() == hours{1});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.mode() == pm);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "1:07pm");
-    t2.make24();
-    os.str("");
-    assert(t2.hours() == hours{13});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.mode() == 0);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "13:07");
+    assert(os.str() == "13:07:00");
 }

test/date_test/time_of_day_nanoseconds.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -27,21 +27,21 @@
 // {
 // public:
 //     using precision = std::chrono::std::chrono::duration<Rep, Period>;
-// 
+//
 //     constexpr explicit time_of_day(precision since_midnight) noexcept;
 //     constexpr time_of_day(std::chrono::hours h, std::chrono::minutes m,
 //                           std::chrono::seconds s, precision sub_s,
 //                           unsigned md) noexcept;
-// 
+//
 //     constexpr std::chrono::hours hours() const noexcept;
 //     constexpr std::chrono::minutes minutes() const noexcept;
 //     constexpr std::chrono::seconds seconds() const noexcept;
 //     constexpr precision subseconds() const noexcept;
 //     constexpr unsigned mode() const noexcept;
-// 
+//
 //     constexpr explicit operator precision() const noexcept;
 //     constexpr precision to_duration() const noexcept;
-// 
+//
 //     void make24() noexcept;
 //     void make12() noexcept;
 // };
@@ -65,10 +65,10 @@ main()
 
     using tod = time_of_day<nanoseconds>;
 
-    static_assert(is_same<tod::precision, nanoseconds>{}, "");
+    static_assert(is_same<tod::precision::period, nanoseconds::period>{}, "");
 
     static_assert( is_trivially_destructible<tod>{}, "");
-    static_assert(!is_default_constructible<tod>{}, "");
+    static_assert( is_default_constructible<tod>{}, "");
     static_assert( is_trivially_copy_constructible<tod>{}, "");
     static_assert( is_trivially_copy_assignable<tod>{}, "");
     static_assert( is_trivially_move_constructible<tod>{}, "");
@@ -76,8 +76,6 @@ main()
 
     static_assert(is_nothrow_constructible<tod, nanoseconds>{}, "");
     static_assert(!is_convertible<nanoseconds, tod>{}, "");
-    static_assert(is_nothrow_constructible<tod, hours, minutes, seconds, nanoseconds,
-                                                unsigned>{}, "");
 
     static_assert(is_nothrow_constructible<tod::precision, tod>{}, "");
     static_assert(!is_convertible<tod, tod::precision>{}, "");
@@ -87,7 +85,6 @@ main()
     static_assert(t1.minutes() == minutes{7}, "");
     static_assert(t1.seconds() == seconds{5}, "");
     static_assert(t1.subseconds() == nanoseconds{22}, "");
-    static_assert(t1.mode() == 0, "");
 #if __cplusplus >= 201402
     static_assert(static_cast<tod::precision>(t1) == hours{13} + minutes{7}
                                                      + seconds{5} + nanoseconds{22}, "");
@@ -100,29 +97,8 @@ main()
     assert(t2.minutes() == t1.minutes());
     assert(t2.seconds() == t1.seconds());
     assert(t2.subseconds() == t1.subseconds());
-    assert(t2.mode() == t1.mode());
     assert(t2.to_duration() == t1.to_duration());
     ostringstream os;
     os << t2;
     assert(os.str() == "13:07:05.000000022");
-    t2.make12();
-    os.str("");
-    assert(t2.hours() == hours{1});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.seconds() == seconds{5});
-    assert(t2.subseconds() == nanoseconds{22});
-    assert(t2.mode() == pm);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "1:07:05.000000022pm");
-    t2.make24();
-    os.str("");
-    assert(t2.hours() == hours{13});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.seconds() == seconds{5});
-    assert(t2.subseconds() == nanoseconds{22});
-    assert(t2.mode() == 0);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "13:07:05.000000022");
 }

test/date_test/time_of_day_seconds.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -26,19 +26,19 @@
 // {
 // public:
 //     using precision = std::chrono::seconds;
-// 
+//
 //     constexpr explicit time_of_day(std::chrono::seconds since_midnight) noexcept;
 //     constexpr time_of_day(std::chrono::hours h, std::chrono::minutes m,
 //                           std::chrono::seconds s, unsigned md) noexcept;
-// 
+//
 //     constexpr std::chrono::hours hours() const noexcept;
 //     constexpr std::chrono::minutes minutes() const noexcept;
 //     constexpr std::chrono::seconds seconds() const noexcept;
 //     constexpr unsigned mode() const noexcept;
-// 
+//
 //     constexpr explicit operator precision() const noexcept;
 //     constexpr precision to_duration() const noexcept;
-// 
+//
 //     void make24() noexcept;
 //     void make12() noexcept;
 // };
@@ -60,10 +60,10 @@ main()
 
     using tod = time_of_day<seconds>;
 
-    static_assert(is_same<tod::precision, seconds>{}, "");
+    static_assert(is_same<tod::precision::period, seconds::period>{}, "");
 
     static_assert( is_trivially_destructible<tod>{}, "");
-    static_assert(!is_default_constructible<tod>{}, "");
+    static_assert( is_default_constructible<tod>{}, "");
     static_assert( is_trivially_copy_constructible<tod>{}, "");
     static_assert( is_trivially_copy_assignable<tod>{}, "");
     static_assert( is_trivially_move_constructible<tod>{}, "");
@@ -71,7 +71,6 @@ main()
 
     static_assert(is_nothrow_constructible<tod, seconds>{}, "");
     static_assert(!is_convertible<seconds, tod>{}, "");
-    static_assert(is_nothrow_constructible<tod, hours, minutes, seconds, unsigned>{}, "");
 
     static_assert(is_nothrow_constructible<tod::precision, tod>{}, "");
     static_assert(!is_convertible<tod, tod::precision>{}, "");
@@ -80,7 +79,6 @@ main()
     static_assert(t1.hours() == hours{13}, "");
     static_assert(t1.minutes() == minutes{7}, "");
     static_assert(t1.seconds() == seconds{5}, "");
-    static_assert(t1.mode() == 0, "");
 #if __cplusplus >= 201402
     static_assert(static_cast<tod::precision>(t1) == hours{13} + minutes{7}
                                                      + seconds{5}, "");
@@ -91,27 +89,8 @@ main()
     assert(t2.hours() == t1.hours());
     assert(t2.minutes() == t1.minutes());
     assert(t2.seconds() == t1.seconds());
-    assert(t2.mode() == t1.mode());
     assert(t2.to_duration() == t1.to_duration());
     ostringstream os;
     os << t2;
     assert(os.str() == "13:07:05");
-    t2.make12();
-    os.str("");
-    assert(t2.hours() == hours{1});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.seconds() == seconds{5});
-    assert(t2.mode() == pm);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "1:07:05pm");
-    t2.make24();
-    os.str("");
-    assert(t2.hours() == hours{13});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.seconds() == seconds{5});
-    assert(t2.mode() == 0);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "13:07:05");
 }

test/date_test/weekday.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -25,19 +25,19 @@
 //     unsigned char wd_;
 // public:
 //     explicit constexpr weekday(unsigned wd) noexcept;
-//     constexpr weekday(const day_point& dp) noexcept;
-// 
+//     constexpr weekday(const sys_days& dp) noexcept;
+//
 //     weekday& operator++()    noexcept;
 //     weekday  operator++(int) noexcept;
 //     weekday& operator--()    noexcept;
 //     weekday  operator--(int) noexcept;
-// 
+//
 //     weekday& operator+=(const days& d) noexcept;
 //     weekday& operator-=(const days& d) noexcept;
-// 
+//
 //     constexpr explicit operator unsigned() const noexcept;
 //     constexpr bool ok() const noexcept;
-// 
+//
 //     // tested with weekday_indexed
 //     constexpr weekday_indexed operator[](unsigned index) const noexcept;
 //     // tested with weekday_last
@@ -69,19 +69,17 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::weekday>{}, "");
-static_assert(!std::is_default_constructible<date::weekday>{}, "");
+static_assert( std::is_default_constructible<date::weekday>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::weekday>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::weekday>{}, "");
 static_assert( std::is_trivially_move_constructible<date::weekday>{}, "");
 static_assert( std::is_trivially_move_assignable<date::weekday>{}, "");
 
 static_assert( std::is_nothrow_constructible<date::weekday, unsigned>{}, "");
-static_assert( std::is_nothrow_constructible<date::weekday, date::day_point>{}, "");
-static_assert( std::is_nothrow_constructible<unsigned, date::weekday>{}, "");
+static_assert( std::is_nothrow_constructible<date::weekday, date::sys_days>{}, "");
 static_assert(!std::is_convertible<unsigned, date::weekday>{}, "");
-static_assert( std::is_convertible<date::day_point, date::weekday>{}, "");
+static_assert( std::is_convertible<date::sys_days, date::weekday>{}, "");
 static_assert(!std::is_convertible<date::weekday, unsigned>{}, "");
-static_assert(static_cast<unsigned>(date::weekday{1u}) == 1, "");
 
 static_assert( date::weekday{0u}.ok(), "");
 static_assert( date::weekday{1u}.ok(), "");
@@ -90,7 +88,8 @@ static_assert( date::weekday{3u}.ok(), "");
 static_assert( date::weekday{4u}.ok(), "");
 static_assert( date::weekday{5u}.ok(), "");
 static_assert( date::weekday{6u}.ok(), "");
-static_assert(!date::weekday{7u}.ok(), "");
+static_assert( date::weekday{7u}.ok(), "");
+static_assert(!date::weekday{8u}.ok(), "");
 
 void
 test_weekday_arithmetic()

test/date_test/weekday_indexed.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -23,16 +23,17 @@
 // class weekday_indexed
 // {
 // public:
+//     weekday_indexed() = default;
 //     constexpr weekday_indexed(const date::weekday& wd, unsigned index) noexcept;
-// 
+//
 //     constexpr date::weekday weekday() const noexcept;
 //     constexpr unsigned index() const noexcept;
 //     constexpr bool ok() const noexcept;
 // };
-// 
+//
 // constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
 // constexpr bool operator!=(const weekday_indexed& x, const weekday_indexed& y) noexcept;
-// 
+//
 // std::ostream& operator<<(std::ostream& os, const weekday_indexed& wdi);
 
 #include "date.h"
@@ -42,7 +43,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::weekday_indexed>{}, "");
-static_assert(!std::is_default_constructible<date::weekday_indexed>{}, "");
+static_assert( std::is_default_constructible<date::weekday_indexed>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::weekday_indexed>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::weekday_indexed>{}, "");
 static_assert( std::is_trivially_move_constructible<date::weekday_indexed>{}, "");

test/date_test/weekday_last.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -24,14 +24,14 @@
 // {
 // public:
 //     explicit constexpr weekday_last(const date::weekday& wd) noexcept;
-// 
+//
 //     constexpr date::weekday weekday() const noexcept;
 //     constexpr bool ok() const noexcept;
 // };
-// 
+//
 // constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
 // constexpr bool operator!=(const weekday_last& x, const weekday_last& y) noexcept;
-// 
+//
 // std::ostream& operator<<(std::ostream& os, const weekday_last& wdl);
 
 #include "date.h"

test/date_test/weekday_lessthan.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/weekday_sum.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/year.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -24,20 +24,20 @@
 // {
 // public:
 //     explicit constexpr year(int y) noexcept;
-// 
+//
 //     year& operator++()    noexcept;
 //     year  operator++(int) noexcept;
 //     year& operator--()    noexcept;
 //     year  operator--(int) noexcept;
-// 
+//
 //     year& operator+=(const years& y) noexcept;
 //     year& operator-=(const years& y) noexcept;
-// 
+//
 //     constexpr bool is_leap() const noexcept;
-// 
+//
 //     constexpr explicit operator int() const noexcept;
 //     constexpr bool ok() const noexcept;
-// 
+//
 //     static constexpr year min() noexcept;
 //     static constexpr year max() noexcept;
 // };
@@ -64,7 +64,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::year>{}, "");
-static_assert(!std::is_default_constructible<date::year>{}, "");
+static_assert( std::is_default_constructible<date::year>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::year>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::year>{}, "");
 static_assert( std::is_trivially_move_constructible<date::year>{}, "");
@@ -107,30 +107,30 @@ main()
     static_assert(year::max().ok(), "");
 
 #if __cplusplus >= 201402
-    using int64_t = std::int64_t;
-    static_assert(day_point(year::min()/jan/1)  - day_point(1970_y/jan/1)
+    using std::int64_t;
+    static_assert(sys_days(year::min()/jan/1)  - sys_days(1970_y/jan/1)
         >= as<int64_t>(days::min()), "");
-    static_assert(day_point(year::min()/jan/1)  - day_point(1970_y/jan/1)
+    static_assert(sys_days(year::min()/jan/1)  - sys_days(1970_y/jan/1)
         >= as<int64_t>(hours::min()), "");
-    static_assert(day_point(year::min()/jan/1)  - day_point(1970_y/jan/1)
+    static_assert(sys_days(year::min()/jan/1)  - sys_days(1970_y/jan/1)
         >= as<int64_t>(minutes::min()), "");
-    static_assert(day_point(year::min()/jan/1)  - day_point(1970_y/jan/1)
+    static_assert(sys_days(year::min()/jan/1)  - sys_days(1970_y/jan/1)
         >= as<int64_t>(seconds::min()), "");
-    static_assert(day_point(year::min()/jan/1)  - day_point(1970_y/jan/1)
+    static_assert(sys_days(year::min()/jan/1)  - sys_days(1970_y/jan/1)
         >= as<int64_t>(milliseconds::min()), "");
-    static_assert(day_point(year::min()/jan/1)  - day_point(1970_y/jan/1)
+    static_assert(sys_days(year::min()/jan/1)  - sys_days(1970_y/jan/1)
         >= as<int64_t>(microseconds::min()), "");
-    static_assert(day_point(year::max()/dec/31) - day_point(1970_y/jan/1)
+    static_assert(sys_days(year::max()/dec/31) - sys_days(1970_y/jan/1)
         <= as<int64_t>(microseconds::max()), "");
-    static_assert(day_point(year::max()/dec/31) - day_point(1970_y/jan/1)
+    static_assert(sys_days(year::max()/dec/31) - sys_days(1970_y/jan/1)
         <= as<int64_t>(milliseconds::max()), "");
-    static_assert(day_point(year::max()/dec/31) - day_point(1970_y/jan/1)
+    static_assert(sys_days(year::max()/dec/31) - sys_days(1970_y/jan/1)
         <= as<int64_t>(seconds::max()), "");
-    static_assert(day_point(year::max()/dec/31) - day_point(1970_y/jan/1)
+    static_assert(sys_days(year::max()/dec/31) - sys_days(1970_y/jan/1)
         <= as<int64_t>(minutes::max()), "");
-    static_assert(day_point(year::max()/dec/31) - day_point(1970_y/jan/1)
+    static_assert(sys_days(year::max()/dec/31) - sys_days(1970_y/jan/1)
         <= as<int64_t>(hours::max()), "");
-    static_assert(day_point(year::max()/dec/31) - day_point(1970_y/jan/1)
+    static_assert(sys_days(year::max()/dec/31) - sys_days(1970_y/jan/1)
         <= as<int64_t>(days::max()), "");
 #endif
 

test/date_test/year_month.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -24,15 +24,15 @@
 // {
 // public:
 //     constexpr year_month(const date::year& y, const date::month& m) noexcept;
-// 
+//
 //     constexpr date::year  year()  const noexcept;
 //     constexpr date::month month() const noexcept;
-// 
+//
 //     year_month& operator+=(const months& dm) noexcept;
 //     year_month& operator-=(const months& dm) noexcept;
 //     year_month& operator+=(const years& dy) noexcept;
 //     year_month& operator-=(const years& dy) noexcept;
-// 
+//
 //     constexpr bool ok() const noexcept;
 // };
 
@@ -61,7 +61,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::year_month>{}, "");
-static_assert(!std::is_default_constructible<date::year_month>{}, "");
+static_assert( std::is_default_constructible<date::year_month>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::year_month>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::year_month>{}, "");
 static_assert( std::is_trivially_move_constructible<date::year_month>{}, "");
@@ -109,6 +109,90 @@ test_arithmetic()
     }
 }
 
+
+void test_arithemtic_not_ok()
+{
+  using namespace date;
+  using namespace std::chrono;
+
+  year_month ym{2018_y, month{14}};
+
+  {
+    year_month ym2{2019_y, month{2}};
+    assert(ym + months{0} == ym2);
+    assert(ym - months{0} == ym2);
+    assert(ym - ym2 == months{0});
+    assert(ym2 - ym == months{0});
+   
+    auto ymc = ym;
+    ymc += months{0};
+    assert(ymc.ok());
+    assert(ymc == ym2);
+  }
+
+  {
+    year_month ym2{2019_y, month{6}};
+    assert(ym + months{4} == ym2);
+    assert(ym2 - ym == months{4});
+    assert(ym - ym2 == -months{4});
+
+    auto ymc = ym;
+    ymc += months{4};
+    assert(ymc.ok());
+    assert(ymc == ym2);
+  }
+
+  {
+    year_month ym2{2018_y, month{10}};
+    assert(ym - months{4} == ym2);
+    assert(ym2 - ym == -months{4});
+    assert(ym - ym2 == months{4});
+
+    auto ymc = ym;
+    ymc -= months{4};
+    assert(ymc.ok());
+    assert(ymc == ym2);
+  }
+
+
+  {
+    year_month ym2{2020_y, month{6}};
+    assert(ym + months{16} == ym2);
+    assert(ym2 - ym == months{16});
+    assert(ym - ym2 == -months{16});
+
+    auto ymc = ym;
+    ymc += months{16};
+    assert(ymc.ok());
+    assert(ymc == ym2);
+  }
+
+  {
+    year_month ym2{2017_y, month{10}};
+    assert(ym - months{16} == ym2);
+    assert(ym2 - ym == -months{16});
+    assert(ym - ym2 == months(16));
+
+    auto ymc = ym;
+    ymc -= months{16};
+    assert(ymc.ok());
+    assert(ymc == ym2);
+  }
+
+  {
+    year_month ym2{2018_y, month{25}};
+    assert(ym2 - ym == months{11});
+    assert(ym - ym2 == -months{11});
+  }
+
+  {
+    year_month ym2{2019_y, month{25}};
+    assert(ym2 - ym == months{23});
+    assert(ym - ym2 == -months{23});
+  }
+
+}
+
 int
 main()
 {
@@ -135,6 +219,7 @@ main()
     static_assert(ym1 - ym2 == -months{11}, "");
 
     test_arithmetic();
+    test_arithemtic_not_ok();
 
     std::ostringstream os;
     os << ym1;

test/date_test/year_month_day.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -26,18 +26,18 @@
 //     constexpr year_month_day(const date::year& y, const date::month& m,
 //                                const date::day& d) noexcept;
 //     constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
-//     constexpr year_month_day(const day_point& dp) noexcept;
-// 
+//     constexpr year_month_day(const sys_days& dp) noexcept;
+//
 //     year_month_day& operator+=(const months& m) noexcept;
 //     year_month_day& operator-=(const months& m) noexcept;
 //     year_month_day& operator+=(const years& y)  noexcept;
 //     year_month_day& operator-=(const years& y)  noexcept;
-// 
+//
 //     constexpr date::year  year()  const noexcept;
 //     constexpr date::month month() const noexcept;
 //     constexpr date::day   day()   const noexcept;
-// 
-//     constexpr operator day_point() const noexcept;
+//
+//     constexpr operator sys_days() const noexcept;
 //     constexpr bool ok() const noexcept;
 // };
 
@@ -64,7 +64,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::year_month_day>{}, "");
-static_assert(!std::is_default_constructible<date::year_month_day>{}, "");
+static_assert( std::is_default_constructible<date::year_month_day>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::year_month_day>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::year_month_day>{}, "");
 static_assert( std::is_trivially_move_constructible<date::year_month_day>{}, "");
@@ -76,10 +76,10 @@ static_assert(std::is_nothrow_constructible<date::year_month_day, date::year,
 static_assert(std::is_nothrow_constructible<date::year_month_day,
                                             date::year_month_day_last>{}, "");
 static_assert(std::is_convertible<date::year_month_day_last, date::year_month_day>{}, "");
-static_assert(std::is_nothrow_constructible<date::year_month_day, date::day_point>{}, "");
-static_assert(std::is_convertible<date::day_point, date::year_month_day>{}, "");
-static_assert(std::is_nothrow_constructible<date::day_point, date::year_month_day>{}, "");
-static_assert(std::is_convertible<date::year_month_day, date::day_point>{}, "");
+static_assert(std::is_nothrow_constructible<date::year_month_day, date::sys_days>{}, "");
+static_assert(std::is_convertible<date::sys_days, date::year_month_day>{}, "");
+static_assert(std::is_nothrow_constructible<date::sys_days, date::year_month_day>{}, "");
+static_assert(std::is_convertible<date::year_month_day, date::sys_days>{}, "");
 
 void
 test_arithmetic()
@@ -131,7 +131,7 @@ test_day_point_conversion()
     using namespace date;
     year y   = year{-1000};
     year end =       3000_y;
-    day_point prev_dp = day_point(year_month_day{y, jan, 1_d}) - days{1};
+    sys_days prev_dp = sys_days(year_month_day{y, jan, 1_d}) - days{1};
     weekday   prev_wd = weekday{prev_dp};
     for (; y <= end; ++y)
     {
@@ -143,7 +143,7 @@ test_day_point_conversion()
             {
                 year_month_day ymd = {y, m, d};
                 assert(ymd.ok());
-                day_point dp = ymd;
+                sys_days dp = ymd;
                 assert(dp == prev_dp + days{1});
                 year_month_day ymd2 = dp;
                 assert(ymd2 == ymd);
@@ -171,7 +171,7 @@ main()
     static_assert(ymd1.day() == 9_d, "");
 
 #if __cplusplus >= 201402
-    constexpr day_point dp = ymd1;
+    constexpr sys_days dp = ymd1;
     static_assert(dp.time_since_epoch() == days{16656}, "");
     constexpr year_month_day ymd2 = dp;
     static_assert(ymd1 == ymd2, "");
@@ -186,7 +186,7 @@ main()
     static_assert(ymd3.day() == 31_d, "");
 
 #if __cplusplus >= 201402
-    constexpr day_point dp3 = ymd3;
+    constexpr sys_days dp3 = ymd3;
     static_assert(dp3.time_since_epoch() == days{-1}, "");
     constexpr year_month_day ymd4 = dp3;
     static_assert(ymd3 == ymd4, "");
@@ -211,9 +211,9 @@ main()
     static_assert( (2100_y/feb/28).ok(), "");
     static_assert(!(2100_y/feb/29).ok(), "");
 
-    static_assert(day_point(2100_y/feb/28) + days{1} == day_point(2100_y/mar/1), "");
-    static_assert(day_point(2000_y/mar/1) - day_point(2000_y/feb/28) == days{2}, "");
-    static_assert(day_point(2100_y/mar/1) - day_point(2100_y/feb/28) == days{1}, "");
+    static_assert(sys_days(2100_y/feb/28) + days{1} == sys_days(2100_y/mar/1), "");
+    static_assert(sys_days(2000_y/mar/1) - sys_days(2000_y/feb/28) == days{2}, "");
+    static_assert(sys_days(2100_y/mar/1) - sys_days(2100_y/feb/28) == days{1}, "");
 
     static_assert(jan/31/2015 == jan/last/2015, "");
     static_assert(feb/28/2015 == feb/last/2015, "");

test/date_test/year_month_day_last.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -25,18 +25,18 @@
 // public:
 //     constexpr year_month_day_last(const date::year& y,
 //                                   const date::month_day_last& mdl) noexcept;
-// 
+//
 //     year_month_day_last& operator+=(const months& m) noexcept;
 //     year_month_day_last& operator-=(const months& m) noexcept;
 //     year_month_day_last& operator+=(const years& y)  noexcept;
 //     year_month_day_last& operator-=(const years& y)  noexcept;
-// 
+//
 //     constexpr date::year           year()           const noexcept;
 //     constexpr date::month          month()          const noexcept;
 //     constexpr date::month_day_last month_day_last() const noexcept;
 //     constexpr date::day            day()            const noexcept;
-// 
-//     constexpr operator day_point() const noexcept;
+//
+//     constexpr operator sys_days() const noexcept;
 //     constexpr bool ok() const noexcept;
 // };
 
@@ -56,23 +56,23 @@
 // constexpr
 // year_month_day_last
 // operator+(const year_month_day_last& ymdl, const months& dm) noexcept;
-// 
+//
 // constexpr
 // year_month_day_last
 // operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
-// 
+//
 // constexpr
 // year_month_day_last
 // operator+(const year_month_day_last& ymdl, const years& dy) noexcept;
-// 
+//
 // constexpr
 // year_month_day_last
 // operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
-// 
+//
 // constexpr
 // year_month_day_last
 // operator-(const year_month_day_last& ymdl, const months& dm) noexcept;
-// 
+//
 // constexpr
 // year_month_day_last
 // operator-(const year_month_day_last& ymdl, const years& dy) noexcept;
@@ -94,9 +94,9 @@ static_assert( std::is_trivially_move_assignable<date::year_month_day_last>{}, "
 
 static_assert(std::is_nothrow_constructible<date::year_month_day_last,
                                                 date::year, date::month_day_last>{}, "");
-static_assert(std::is_nothrow_constructible<date::day_point,
+static_assert(std::is_nothrow_constructible<date::sys_days,
                                                 date::year_month_day_last>{}, "");
-static_assert(std::is_convertible<date::year_month_day_last, date::day_point>{}, "");
+static_assert(std::is_convertible<date::year_month_day_last, date::sys_days>{}, "");
 
 void
 test_arithmetic()
@@ -105,7 +105,7 @@ test_arithmetic()
 
     for (int y1 = 2010; y1 <= 2015; ++y1)
     {
-        for (unsigned m1 = 1; m1 <= 12; ++m1)
+        for (int m1 = 1; m1 <= 12; ++m1)
         {
             auto ymd1 = last/m1/y1;;
             auto ymd2 = ymd1 + months(24);
@@ -154,7 +154,7 @@ main()
     static_assert(ymdl1.month_day_last() == month_day_last{aug}, "");
 #if __cplusplus >= 201402
     static_assert(ymdl1.day() == 31_d, "");
-    constexpr day_point dp = ymdl1;
+    constexpr sys_days dp = ymdl1;
     constexpr year_month_day ymd = dp;
     static_assert(ymd == 2015_y/aug/31, "");
 #endif

test/date_test/year_month_day_m_year_month_day.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/year_month_day_p_year_month_day.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/year_month_p_year_month.fail.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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

test/date_test/year_month_weekday.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -23,26 +23,27 @@
 // class year_month_weekday
 // {
 // public:
+//     year_month_weekday() = default;
 //     constexpr year_month_weekday(const date::year& y, const date::month& m,
 //                                    const date::weekday_indexed& wdi) noexcept;
-//     constexpr year_month_weekday(const day_point& dp) noexcept;
-// 
+//     constexpr year_month_weekday(const sys_days& dp) noexcept;
+//
 //     year_month_weekday& operator+=(const months& m) noexcept;
 //     year_month_weekday& operator-=(const months& m) noexcept;
 //     year_month_weekday& operator+=(const years& y)  noexcept;
 //     year_month_weekday& operator-=(const years& y)  noexcept;
-// 
+//
 //     constexpr date::year year() const noexcept;
 //     constexpr date::month month() const noexcept;
 //     constexpr date::weekday weekday() const noexcept;
 //     constexpr unsigned index() const noexcept;
 //     constexpr date::weekday_indexed weekday_indexed() const noexcept;
-// 
-//     constexpr operator day_point() const noexcept;
+//
+//     constexpr operator sys_days() const noexcept;
 //     constexpr bool ok() const noexcept;
-// 
+//
 // private:
-//     static constexpr year_month_weekday from_day_point(const day_point& dp) noexcept;
+//     static constexpr year_month_weekday from_day_point(const sys_days& dp) noexcept;
 // };
 
 // constexpr
@@ -53,23 +54,23 @@
 // constexpr
 // year_month_weekday
 // operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
-// 
+//
 // constexpr
 // year_month_weekday
 // operator+(const months& dm, const year_month_weekday& ymwd) noexcept;
-// 
+//
 // constexpr
 // year_month_weekday
 // operator+(const year_month_weekday& ymwd, const years& dy) noexcept;
-// 
+//
 // constexpr
 // year_month_weekday
 // operator+(const years& dy, const year_month_weekday& ymwd) noexcept;
-// 
+//
 // constexpr
 // year_month_weekday
 // operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
-// 
+//
 // constexpr
 // year_month_weekday
 // operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
@@ -83,7 +84,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::year_month_weekday>{}, "");
-static_assert(!std::is_default_constructible<date::year_month_weekday>{}, "");
+static_assert( std::is_default_constructible<date::year_month_weekday>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::year_month_weekday>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::year_month_weekday>{}, "");
 static_assert( std::is_trivially_move_constructible<date::year_month_weekday>{}, "");
@@ -93,11 +94,11 @@ static_assert(std::is_nothrow_constructible<date::year_month_weekday,
                                                 date::year, date::month,
                                                 date::weekday_indexed>{}, "");
 static_assert(std::is_nothrow_constructible<date::year_month_weekday,
-                                                date::day_point>{}, "");
-static_assert(std::is_convertible<date::day_point, date::year_month_weekday>{}, "");
-static_assert(std::is_nothrow_constructible<date::day_point,
+                                                date::sys_days>{}, "");
+static_assert(std::is_convertible<date::sys_days, date::year_month_weekday>{}, "");
+static_assert(std::is_nothrow_constructible<date::sys_days,
                                                 date::year_month_weekday>{}, "");
-static_assert(std::is_convertible<date::year_month_weekday, date::day_point>{}, "");
+static_assert(std::is_convertible<date::year_month_weekday, date::sys_days>{}, "");
 
 void
 test_arithmetic()
@@ -106,7 +107,7 @@ test_arithmetic()
 
     for (int y1 = 2010; y1 <= 2015; ++y1)
     {
-        for (unsigned m1 = 1; m1 <= 12; ++m1)
+        for (int m1 = 1; m1 <= 12; ++m1)
         {
             auto ymd1 = mon[2]/m1/y1;;
             auto ymd2 = ymd1 + months(24);
@@ -158,7 +159,7 @@ main()
     static_assert(ymdl1.index() == 2u, "");
     static_assert(ymdl1.weekday_indexed() == fri[2], "");
 #if __cplusplus >= 201402
-    constexpr day_point dp = ymdl1;
+    constexpr sys_days dp = ymdl1;
     constexpr year_month_day ymd = dp;
     static_assert(ymd == 2015_y/aug/14, "");
 #endif

test/date_test/year_month_weekday_last.pass.cpp

@@ -1,17 +1,17 @@
 // The MIT License (MIT)
-// 
-// Copyright (c) 2015 Howard Hinnant
-// 
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
-// 
+//
 // 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
@@ -25,25 +25,25 @@
 // public:
 //     constexpr year_month_weekday_last(const date::year& y, const date::month& m,
 //                                       const date::weekday_last& wdl) noexcept;
-// 
+//
 //     year_month_weekday_last& operator+=(const months& m) noexcept;
 //     year_month_weekday_last& operator-=(const months& m) noexcept;
 //     year_month_weekday_last& operator+=(const years& y) noexcept;
 //     year_month_weekday_last& operator-=(const years& y) noexcept;
-// 
+//
 //     constexpr date::year year() const noexcept;
 //     constexpr date::month month() const noexcept;
 //     constexpr date::weekday weekday() const noexcept;
 //     constexpr date::weekday_last weekday_last() const noexcept;
-// 
-//     constexpr operator day_point() const noexcept;
+//
+//     constexpr operator sys_days() const noexcept;
 //     constexpr bool ok() const noexcept;
 // };
 
 // constexpr
 // bool
 // operator==(const year_month_weekday_last& x, const year_month_weekday_last& y) noexcept;
-// 
+//
 // constexpr
 // bool
 // operator!=(const year_month_weekday_last& x, const year_month_weekday_last& y) noexcept;
@@ -51,23 +51,23 @@
 // constexpr
 // year_month_weekday_last
 // operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
-// 
+//
 // constexpr
 // year_month_weekday_last
 // operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept;
-// 
+//
 // constexpr
 // year_month_weekday_last
 // operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
-// 
+//
 // constexpr
 // year_month_weekday_last
 // operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept;
-// 
+//
 // constexpr
 // year_month_weekday_last
 // operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
-// 
+//
 // constexpr
 // year_month_weekday_last
 // operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
@@ -90,9 +90,9 @@ static_assert( std::is_trivially_move_assignable<date::year_month_weekday_last>{
 static_assert(std::is_nothrow_constructible<date::year_month_weekday_last,
                                                 date::year, date::month,
                                                 date::weekday_last>{}, "");
-static_assert(std::is_nothrow_constructible<date::day_point,
+static_assert(std::is_nothrow_constructible<date::sys_days,
                                                 date::year_month_weekday_last>{}, "");
-static_assert(std::is_convertible<date::year_month_weekday_last, date::day_point>{}, "");
+static_assert(std::is_convertible<date::year_month_weekday_last, date::sys_days>{}, "");
 
 void
 test_arithmetic()
@@ -101,7 +101,7 @@ test_arithmetic()
 
     for (int y1 = 2010; y1 <= 2015; ++y1)
     {
-        for (unsigned m1 = 1; m1 <= 12; ++m1)
+        for (int m1 = 1; m1 <= 12; ++m1)
         {
             auto ymd1 = mon[last]/m1/y1;;
             auto ymd2 = ymd1 + months(24);
@@ -150,7 +150,7 @@ main()
     static_assert(ymdl1.weekday() == fri, "");
     static_assert(ymdl1.weekday_last() == fri[last], "");
 #if __cplusplus >= 201402
-    constexpr day_point dp = ymdl1;
+    constexpr sys_days dp = ymdl1;
     constexpr year_month_day ymd = dp;
     static_assert(ymd == 2015_y/aug/28, "");
 #endif