mirror of
https://git.wownero.com/wownero/onion-wownero-blockchain-explorer.git
synced 2024-08-15 00:33:12 +00:00
3121 lines
93 KiB
C++
3121 lines
93 KiB
C++
// The MIT License (MIT)
|
|
//
|
|
// Copyright (c) 2015, 2016 Howard Hinnant
|
|
// Copyright (c) 2015 Ville Voutilainen
|
|
// 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.
|
|
//
|
|
// Our apologies. When the previous paragraph was written, lowercase had not yet
|
|
// been invented (that woud involve another several millennia of evolution).
|
|
// We did not mean to shout.
|
|
|
|
#ifdef _WIN32
|
|
// Windows.h will be included directly and indirectly (e.g. by curl).
|
|
// We need to define these macros to prevent Windows.h bringing in
|
|
// more than we need and do it eearly so Windows.h doesn't get included
|
|
// without these macros having been defined.
|
|
// min/max macrosinterfere with the C++ versions.
|
|
#ifndef NOMINMAX
|
|
#define NOMINMAX
|
|
#endif
|
|
// We don't need all that Windows has to offer.
|
|
#ifndef WIN32_LEAN_AND_MEAN
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#endif // _WIN32
|
|
|
|
// None of this happens with the MS SDK (at least VS14 which I tested), but:
|
|
// Compiling with mingw, we get "error: 'KF_FLAG_DEFAULT' was not declared in this scope."
|
|
// and error: 'SHGetKnownFolderPath' was not declared in this scope.".
|
|
// It seems when using mingw NTDDI_VERSION is undefined and that
|
|
// causes KNOWN_FOLDER_FLAG and the KF_ flags to not get defined.
|
|
// So we must define NTDDI_VERSION to get those flags on mingw.
|
|
// The docs say though here:
|
|
// https://msdn.microsoft.com/en-nz/library/windows/desktop/aa383745(v=vs.85).aspx
|
|
// that "If you define NTDDI_VERSION, you must also define _WIN32_WINNT."
|
|
// So we declare we require Vista or greater.
|
|
#ifdef __MINGW32__
|
|
|
|
#ifndef NTDDI_VERSION
|
|
#define NTDDI_VERSION 0x06000000
|
|
#define _WIN32_WINNT _WIN32_WINNT_VISTA
|
|
#elif NTDDI_VERSION < 0x06000000
|
|
#warning "If this fails to compile NTDDI_VERSION may be to low. See comments above."
|
|
#endif
|
|
// But once we define the values above we then get this linker error:
|
|
// "tz.cpp:(.rdata$.refptr.FOLDERID_Downloads[.refptr.FOLDERID_Downloads]+0x0): "
|
|
// "undefined reference to `FOLDERID_Downloads'"
|
|
// which #include <initguid.h> cures see:
|
|
// https://support.microsoft.com/en-us/kb/130869
|
|
#include <initguid.h>
|
|
// But with <initguid.h> included, the error moves on to:
|
|
// error: 'FOLDERID_Downloads' was not declared in this scope
|
|
// Which #include <knownfolders.h> cures.
|
|
#include <knownfolders.h>
|
|
|
|
#endif // __MINGW32__
|
|
|
|
#include <Windows.h>
|
|
#endif // _WIN32
|
|
|
|
#include "tz_private.h"
|
|
#include "ios.h"
|
|
|
|
#include <algorithm>
|
|
#include <cctype>
|
|
#include <cstdlib>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <iterator>
|
|
#include <memory>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <sys/stat.h>
|
|
|
|
#ifdef _WIN32
|
|
#include <locale>
|
|
#include <codecvt>
|
|
#endif // _WIN32
|
|
|
|
// unistd.h is used on some platforms as part of the the means to get
|
|
// the current time zone. On Win32 Windows.h provides a means to do it.
|
|
// gcc/mingw supports unistd.h on Win32 but MSVC does not.
|
|
|
|
#ifdef _WIN32
|
|
# include <io.h> // _unlink etc.
|
|
# include <ShlObj.h> // CoTaskFree, ShGetKnownFolderPath etc.
|
|
# if HAS_REMOTE_API
|
|
# include <direct.h> // _mkdir
|
|
# include <Shellapi.h> // ShFileOperation etc.
|
|
# endif // HAS_REMOTE_API
|
|
#else // !WIN32
|
|
# include <unistd.h>
|
|
# include <wordexp.h>
|
|
# if !USE_SHELL_API
|
|
# include <sys/stat.h>
|
|
# include <sys/fcntl.h>
|
|
# include <dirent.h>
|
|
# include <cstring>
|
|
# include <sys/wait.h>
|
|
# include <sys/types.h>
|
|
# endif //!USE_SHELL_API
|
|
#endif // !WIN32
|
|
|
|
|
|
#if HAS_REMOTE_API
|
|
// Note curl includes windows.h so we must include curl AFTER definitions of things
|
|
// that effect windows.h such as NOMINMAX.
|
|
#include <curl/curl.h>
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
static CONSTDATA char folder_delimiter = '\\';
|
|
|
|
namespace
|
|
{
|
|
struct task_mem_deleter
|
|
{
|
|
void operator()(wchar_t buf[])
|
|
{
|
|
if (buf != nullptr)
|
|
CoTaskMemFree(buf);
|
|
}
|
|
};
|
|
using co_task_mem_ptr = std::unique_ptr<wchar_t[], task_mem_deleter>;
|
|
}
|
|
|
|
// We might need to know certain locations even if not using the remote API,
|
|
// so keep these routines out of that block for now.
|
|
static
|
|
std::string
|
|
get_known_folder(const GUID& folderid)
|
|
{
|
|
std::string folder;
|
|
PWSTR pfolder = nullptr;
|
|
HRESULT hr = SHGetKnownFolderPath(folderid, KF_FLAG_DEFAULT, NULL, &pfolder);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
co_task_mem_ptr folder_ptr(pfolder);
|
|
folder = std::string(folder_ptr.get(), folder_ptr.get() + wcslen(folder_ptr.get()));
|
|
}
|
|
return folder;
|
|
}
|
|
|
|
// Usually something like "c:\Program Files".
|
|
static
|
|
std::string
|
|
get_program_folder()
|
|
{
|
|
return get_known_folder(FOLDERID_ProgramFiles);
|
|
}
|
|
|
|
// Usually something like "c:\Users\username\Downloads".
|
|
static
|
|
std::string
|
|
get_download_folder()
|
|
{
|
|
return get_known_folder(FOLDERID_Downloads);
|
|
}
|
|
|
|
#else // !_WIN32
|
|
|
|
static CONSTDATA char folder_delimiter = '/';
|
|
|
|
static
|
|
std::string
|
|
expand_path(std::string path)
|
|
{
|
|
#if TARGET_OS_IPHONE
|
|
return date::iOSUtils::get_tzdata_path();
|
|
#else
|
|
::wordexp_t w{};
|
|
::wordexp(path.c_str(), &w, 0);
|
|
assert(w.we_wordc == 1);
|
|
path = w.we_wordv[0];
|
|
::wordfree(&w);
|
|
return path;
|
|
#endif
|
|
}
|
|
|
|
#endif // !_WIN32
|
|
|
|
namespace date
|
|
{
|
|
// +---------------------+
|
|
// | Begin Configuration |
|
|
// +---------------------+
|
|
|
|
using namespace detail;
|
|
|
|
static std::string get_install()
|
|
{
|
|
#ifdef _WIN32
|
|
std::string install = get_download_folder();
|
|
install += folder_delimiter;
|
|
install += "tzdata";
|
|
#else
|
|
std::string install = expand_path("~/Downloads/tzdata");
|
|
#endif
|
|
return install;
|
|
}
|
|
|
|
#ifndef INSTALL
|
|
|
|
static const std::string install = get_install();
|
|
|
|
#else // INSTALL
|
|
|
|
#define STRINGIZEIMP(x) #x
|
|
#define STRINGIZE(x) STRINGIZEIMP(x)
|
|
|
|
static const std::string install = STRINGIZE(INSTALL) +
|
|
std::string(1, folder_delimiter) + "tzdata";
|
|
|
|
#endif // INSTALL
|
|
|
|
static
|
|
std::string
|
|
get_download_gz_file(const std::string& version)
|
|
{
|
|
auto file = install + version + ".tar.gz";
|
|
return file;
|
|
}
|
|
|
|
static const std::vector<std::string> files =
|
|
{
|
|
"africa", "antarctica", "asia", "australasia", "backward", "etcetera", "europe",
|
|
"pacificnew", "northamerica", "southamerica", "systemv", "leapseconds"
|
|
};
|
|
|
|
// These can be used to reduce the range of the database to save memory
|
|
CONSTDATA auto min_year = date::year::min();
|
|
CONSTDATA auto max_year = date::year::max();
|
|
|
|
CONSTDATA auto min_day = date::jan/1;
|
|
CONSTDATA auto max_day = date::dec/31;
|
|
|
|
// +-------------------+
|
|
// | End Configuration |
|
|
// +-------------------+
|
|
|
|
namespace detail
|
|
{
|
|
struct undocumented {explicit undocumented() = default;};
|
|
}
|
|
|
|
#ifndef _MSC_VER
|
|
static_assert(min_year <= max_year, "Configuration error");
|
|
#endif
|
|
|
|
#ifdef TIMEZONE_MAPPING
|
|
|
|
namespace // Put types in an anonymous name space.
|
|
{
|
|
|
|
// A simple type to manage RAII for key handles and to
|
|
// implement the trivial registry interface we need.
|
|
// Not intended to be general-purpose.
|
|
class reg_key
|
|
{
|
|
private:
|
|
// Note there is no value documented to be an invalid handle value.
|
|
// Not NULL nor INVALID_HANDLE_VALUE. We must rely on is_open.
|
|
HKEY m_key = nullptr;
|
|
bool m_is_open = false;
|
|
public:
|
|
~reg_key()
|
|
{
|
|
close();
|
|
}
|
|
|
|
reg_key() = default;
|
|
reg_key(const reg_key&) = delete;
|
|
reg_key& operator=(const reg_key&) = delete;
|
|
|
|
HKEY handle()
|
|
{
|
|
return m_key;
|
|
}
|
|
|
|
bool is_open() const
|
|
{
|
|
return m_is_open;
|
|
}
|
|
|
|
LONG open(const wchar_t* key_name)
|
|
{
|
|
LONG result;
|
|
result = RegOpenKeyExW(HKEY_LOCAL_MACHINE, key_name, 0, KEY_READ, &m_key);
|
|
if (result == ERROR_SUCCESS)
|
|
m_is_open = true;
|
|
return result;
|
|
}
|
|
|
|
LONG close()
|
|
{
|
|
if (m_is_open)
|
|
{
|
|
auto result = RegCloseKey(m_key);
|
|
assert(result == ERROR_SUCCESS);
|
|
if (result == ERROR_SUCCESS)
|
|
{
|
|
m_is_open = false;
|
|
m_key = nullptr;
|
|
}
|
|
return result;
|
|
}
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
// WARNING: this function is not a general-purpose function.
|
|
// It has a hard-coded value size limit that should be sufficient for our use cases.
|
|
bool get_string(const wchar_t* key_name, std::string& value, std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>& converter)
|
|
{
|
|
value.clear();
|
|
wchar_t value_buffer[256];
|
|
// in/out parameter. Documentation say that size is a count of bytes not chars.
|
|
DWORD size = sizeof(value_buffer) - sizeof(value_buffer[0]);
|
|
DWORD tzi_type = REG_SZ;
|
|
if (RegQueryValueExW(handle(), key_name, nullptr, &tzi_type,
|
|
reinterpret_cast<LPBYTE>(value_buffer), &size) == ERROR_SUCCESS)
|
|
{
|
|
// Function does not guarantee to null terminate.
|
|
value_buffer[size/sizeof(value_buffer[0])] = L'\0';
|
|
value = converter.to_bytes(value_buffer);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool get_binary(const wchar_t* key_name, void* value, int value_size)
|
|
{
|
|
DWORD size = value_size;
|
|
DWORD type = REG_BINARY;
|
|
if (RegQueryValueExW(handle(), key_name, nullptr, &type,
|
|
reinterpret_cast<LPBYTE>(value), &size) == ERROR_SUCCESS
|
|
&& (int) size == value_size)
|
|
return true;
|
|
return false;
|
|
}
|
|
};
|
|
|
|
} // anonymous namespace
|
|
|
|
static
|
|
std::string
|
|
get_download_mapping_file(const std::string& version)
|
|
{
|
|
auto file = install + version + "windowsZones.xml";
|
|
return file;
|
|
}
|
|
|
|
// Parse this XML file:
|
|
// http://unicode.org/repos/cldr/trunk/common/supplemental/windowsZones.xml
|
|
// The parsing method is designed to be simple and quick. It is not overly
|
|
// forgiving of change but it should diagnose basic format issues.
|
|
// See timezone_mapping structure for more info.
|
|
static
|
|
std::vector<detail::timezone_mapping>
|
|
load_timezone_mappings_from_xml_file(const std::string& input_path)
|
|
{
|
|
std::size_t line_num = 0;
|
|
std::vector<detail::timezone_mapping> mappings;
|
|
std::string line;
|
|
|
|
std::ifstream is(input_path);
|
|
if (!is.is_open())
|
|
{
|
|
// We don't emit file exceptions because that's an implementation detail.
|
|
std::string msg = "Error opening time zone mapping file \"";
|
|
msg += input_path;
|
|
msg += "\".";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
|
|
auto error = [&input_path, &line_num](const char* info)
|
|
{
|
|
std::string msg = "Error loading time zone mapping file \"";
|
|
msg += input_path;
|
|
msg += "\" at line ";
|
|
msg += std::to_string(line_num);
|
|
msg += ": ";
|
|
msg += info;
|
|
throw std::runtime_error(msg);
|
|
};
|
|
// [optional space]a="b"
|
|
auto read_attribute = [&line_num, &line, &error]
|
|
(const char* name, std::string& value, std::size_t startPos)
|
|
->std::size_t
|
|
{
|
|
value.clear();
|
|
// Skip leading space before attribute name.
|
|
std::size_t spos = line.find_first_not_of(' ', startPos);
|
|
if (spos == std::string::npos)
|
|
spos = startPos;
|
|
// Assume everything up to next = is the attribute name
|
|
// and that an = will always delimit that.
|
|
std::size_t epos = line.find('=', spos);
|
|
if (epos == std::string::npos)
|
|
error("Expected \'=\' right after attribute name.");
|
|
std::size_t name_len = epos - spos;
|
|
// Expect the name we find matches the name we expect.
|
|
if (line.compare(spos, name_len, name) != 0)
|
|
{
|
|
std::string msg;
|
|
msg = "Expected attribute name \'";
|
|
msg += name;
|
|
msg += "\' around position ";
|
|
msg += std::to_string(spos);
|
|
msg += " but found something else.";
|
|
error(msg.c_str());
|
|
}
|
|
++epos; // Skip the '=' that is after the attribute name.
|
|
spos = epos;
|
|
if (spos < line.length() && line[spos] == '\"')
|
|
++spos; // Skip the quote that is before the attribute value.
|
|
else
|
|
{
|
|
std::string msg = "Expected '\"' to begin value of attribute \'";
|
|
msg += name;
|
|
msg += "\'.";
|
|
error(msg.c_str());
|
|
}
|
|
epos = line.find('\"', spos);
|
|
if (epos == std::string::npos)
|
|
{
|
|
std::string msg = "Expected '\"' to end value of attribute \'";
|
|
msg += name;
|
|
msg += "\'.";
|
|
error(msg.c_str());
|
|
}
|
|
// Extract everything in between the quotes. Note no escaping is done.
|
|
std::size_t value_len = epos - spos;
|
|
value.assign(line, spos, value_len);
|
|
++epos; // Skip the quote that is after the attribute value;
|
|
return epos;
|
|
};
|
|
|
|
// Quick but not overly forgiving XML mapping file processing.
|
|
bool mapTimezonesOpenTagFound = false;
|
|
bool mapTimezonesCloseTagFound = false;
|
|
bool mapZoneOpenTagFound = false;
|
|
bool mapTZoneCloseTagFound = false;
|
|
std::size_t mapZonePos = std::string::npos;
|
|
std::size_t mapTimezonesPos = std::string::npos;
|
|
CONSTDATA char mapTimeZonesOpeningTag[] = { "<mapTimezones " };
|
|
CONSTDATA char mapZoneOpeningTag[] = { "<mapZone " };
|
|
CONSTDATA std::size_t mapZoneOpeningTagLen = sizeof(mapZoneOpeningTag) /
|
|
sizeof(mapZoneOpeningTag[0]) - 1;
|
|
while (!mapTimezonesOpenTagFound)
|
|
{
|
|
std::getline(is, line);
|
|
++line_num;
|
|
if (is.eof())
|
|
{
|
|
// If there is no mapTimezones tag is it an error?
|
|
// Perhaps if there are no mapZone mappings it might be ok for
|
|
// its parent mapTimezones element to be missing?
|
|
// We treat this as an error though on the assumption that if there
|
|
// really are no mappings we should still get a mapTimezones parent
|
|
// element but no mapZone elements inside. Assuming we must
|
|
// find something will hopefully at least catch more drastic formatting
|
|
// changes or errors than if we don't do this and assume nothing found.
|
|
error("Expected a mapTimezones opening tag.");
|
|
}
|
|
mapTimezonesPos = line.find(mapTimeZonesOpeningTag);
|
|
mapTimezonesOpenTagFound = (mapTimezonesPos != std::string::npos);
|
|
}
|
|
|
|
// NOTE: We could extract the version info that follows the opening
|
|
// mapTimezones tag and compare that to the version of other data we have.
|
|
// I would have expected them to be kept in synch but testing has shown
|
|
// it is typically does not match anyway. So what's the point?
|
|
while (!mapTimezonesCloseTagFound)
|
|
{
|
|
std::getline(is, line);
|
|
++line_num;
|
|
if (is.eof())
|
|
error("Expected a mapTimezones closing tag.");
|
|
if (line.empty())
|
|
continue;
|
|
mapZonePos = line.find(mapZoneOpeningTag);
|
|
if (mapZonePos != std::string::npos)
|
|
{
|
|
mapZonePos += mapZoneOpeningTagLen;
|
|
detail::timezone_mapping zm{};
|
|
std::size_t pos = read_attribute("other", zm.other, mapZonePos);
|
|
pos = read_attribute("territory", zm.territory, pos);
|
|
read_attribute("type", zm.type, pos);
|
|
mappings.push_back(std::move(zm));
|
|
|
|
continue;
|
|
}
|
|
mapTimezonesPos = line.find("</mapTimezones>");
|
|
mapTimezonesCloseTagFound = (mapTimezonesPos != std::string::npos);
|
|
if (!mapTimezonesCloseTagFound)
|
|
{
|
|
std::size_t commentPos = line.find("<!--");
|
|
if (commentPos == std::string::npos)
|
|
error("Unexpected mapping record found. A xml mapZone or comment "
|
|
"attribute or mapTimezones closing tag was expected.");
|
|
}
|
|
}
|
|
|
|
is.close();
|
|
return mappings;
|
|
}
|
|
|
|
static
|
|
void
|
|
sort_zone_mappings(std::vector<date::detail::timezone_mapping>& mappings)
|
|
{
|
|
std::sort(mappings.begin(), mappings.end(),
|
|
[](const date::detail::timezone_mapping& lhs,
|
|
const date::detail::timezone_mapping& rhs)->bool
|
|
{
|
|
auto other_result = lhs.other.compare(rhs.other);
|
|
if (other_result < 0)
|
|
return true;
|
|
else if (other_result == 0)
|
|
{
|
|
auto territory_result = lhs.territory.compare(rhs.territory);
|
|
if (territory_result < 0)
|
|
return true;
|
|
else if (territory_result == 9)
|
|
{
|
|
if (lhs.type < rhs.type)
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
}
|
|
|
|
// This routine maps Win32 OS error codes to readable text strngs.
|
|
static
|
|
std::string
|
|
get_win32_message(DWORD error_code)
|
|
{
|
|
struct free_message {
|
|
void operator()(char buf[]) {
|
|
if (buf != nullptr)
|
|
{
|
|
auto result = HeapFree(GetProcessHeap(), 0, buf);
|
|
assert(result != 0);
|
|
}
|
|
}
|
|
};
|
|
char* msg = nullptr;
|
|
auto result = FormatMessageA(
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM
|
|
| FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
reinterpret_cast<char*>(&msg), 0, nullptr );
|
|
std::unique_ptr<char[], free_message> message_buffer(msg);
|
|
if (result == 0) // If there is no error message, still give the code.
|
|
{
|
|
std::string err = "Error getting message for error number ";
|
|
err += std::to_string(error_code);
|
|
return err;
|
|
}
|
|
assert(message_buffer.get() != nullptr);
|
|
return std::string(message_buffer.get());
|
|
}
|
|
|
|
// This function returns an exhaustive list of time zone information
|
|
// from the Windows registry.
|
|
// The routine tries to load as many time zone entries as possible despite errors.
|
|
// We don't want to fail to load the whole database just because one record can't be read.
|
|
|
|
static
|
|
void
|
|
get_windows_timezone_info(std::vector<detail::timezone_info>& tz_list)
|
|
{
|
|
tz_list.clear();
|
|
LONG result;
|
|
|
|
// Open the parent time zone key that has the list of timezones in.
|
|
reg_key zones_key;
|
|
static const wchar_t zones_key_name[] =
|
|
{ L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones" };
|
|
result = zones_key.open(zones_key_name);
|
|
// TODO! Review if this should happen here or be signalled later.
|
|
// We don't want the process to fail on startup because of this.
|
|
if (result != ERROR_SUCCESS)
|
|
throw std::runtime_error("Time Zone registry key could not be opened: "
|
|
+ get_win32_message(result));
|
|
|
|
DWORD size;
|
|
wchar_t zone_key_name[256];
|
|
std::wstring value;
|
|
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
|
|
|
|
// Iterate through the list of keys of the parent time zones key to get
|
|
// each key that identifies each individual timezone.
|
|
std::wstring full_zone_key_name;
|
|
for (DWORD zone_index = 0; ; ++zone_index)
|
|
{
|
|
detail::timezone_info tz;
|
|
|
|
size = (DWORD) sizeof(zone_key_name)/sizeof(zone_key_name[0]);
|
|
auto status = RegEnumKeyExW(zones_key.handle(), zone_index, zone_key_name, &size,
|
|
nullptr, nullptr, nullptr, nullptr);
|
|
if (status != ERROR_SUCCESS && status != ERROR_NO_MORE_ITEMS)
|
|
throw std::runtime_error("Can't enumerate time zone registry key"
|
|
+ get_win32_message(status));
|
|
if (status == ERROR_NO_MORE_ITEMS)
|
|
break;
|
|
tz.timezone_id = converter.to_bytes(zone_key_name);
|
|
|
|
full_zone_key_name = zones_key_name;
|
|
full_zone_key_name += L'\\';
|
|
full_zone_key_name += zone_key_name;
|
|
|
|
// If any field fails to be found, consider the whole time zone
|
|
// entry corrupt and move onto the next. See comments
|
|
// at the top of function.
|
|
|
|
reg_key zone_key;
|
|
if (zone_key.open(full_zone_key_name.c_str()) != ERROR_SUCCESS)
|
|
continue;
|
|
|
|
if (!zone_key.get_string(L"Std", tz.standard_name, converter))
|
|
continue;
|
|
|
|
#if 0
|
|
// TBD these fields are not required yet.
|
|
// They might be useful for test cases though.
|
|
if (!zone_key.get_string("Display", tz.display_name, converter))
|
|
continue;
|
|
|
|
if (!zone_key.get_binary("TZI", &tz.tzi, sizeof(TZI)))
|
|
continue;
|
|
#endif
|
|
zone_key.close();
|
|
|
|
tz_list.push_back(std::move(tz));
|
|
}
|
|
result = zones_key.close();
|
|
}
|
|
|
|
// standard_name is the StandardName field from the Windows
|
|
// TIME_ZONE_INFORMATION structure.
|
|
// See the Windows API function GetTimeZoneInformation.
|
|
// The standard_name is also the value from STD field of
|
|
// under the windows registry key Time Zones.
|
|
// To be clear, standard_name does NOT represent a windows timezone id
|
|
// or an IANA tzid
|
|
static
|
|
const detail::timezone_info*
|
|
find_native_timezone_by_standard_name(const std::string& standard_name)
|
|
{
|
|
// TODO! we can improve on linear search.
|
|
const auto& native_zones = get_tzdb().native_zones;
|
|
for (const auto& tz : native_zones)
|
|
{
|
|
if (tz.standard_name == standard_name)
|
|
return &tz;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
static
|
|
bool
|
|
native_to_standard_timezone_name(const std::string& native_tz_name,
|
|
std::string& standard_tz_name)
|
|
{
|
|
// TOOD! Need be a case insensitive compare?
|
|
if (native_tz_name == "UTC")
|
|
{
|
|
standard_tz_name = "Etc/UTC";
|
|
return true;
|
|
}
|
|
standard_tz_name.clear();
|
|
// TODO! we can improve on linear search.
|
|
const auto& mappings = date::get_tzdb().mappings;
|
|
for (const auto& tzm : mappings)
|
|
{
|
|
if (tzm.other == native_tz_name)
|
|
{
|
|
standard_tz_name = tzm.type;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#endif // TIMEZONE_MAPPING
|
|
|
|
// Parsing helpers
|
|
|
|
static
|
|
std::string
|
|
parse3(std::istream& in)
|
|
{
|
|
std::string r(3, ' ');
|
|
ws(in);
|
|
r[0] = static_cast<char>(in.get());
|
|
r[1] = static_cast<char>(in.get());
|
|
r[2] = static_cast<char>(in.get());
|
|
return r;
|
|
}
|
|
|
|
static
|
|
unsigned
|
|
parse_dow(std::istream& in)
|
|
{
|
|
const char*const dow_names[] =
|
|
{"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
|
|
auto s = parse3(in);
|
|
auto dow = std::find(std::begin(dow_names), std::end(dow_names), s) - dow_names;
|
|
if (dow >= std::end(dow_names) - std::begin(dow_names))
|
|
throw std::runtime_error("oops: bad dow name: " + s);
|
|
return static_cast<unsigned>(dow);
|
|
}
|
|
|
|
static
|
|
unsigned
|
|
parse_month(std::istream& in)
|
|
{
|
|
const char*const month_names[] =
|
|
{"Jan", "Feb", "Mar", "Apr", "May", "Jun",
|
|
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
|
|
auto s = parse3(in);
|
|
auto m = std::find(std::begin(month_names), std::end(month_names), s) - month_names;
|
|
if (m >= std::end(month_names) - std::begin(month_names))
|
|
throw std::runtime_error("oops: bad month name: " + s);
|
|
return static_cast<unsigned>(++m);
|
|
}
|
|
|
|
static
|
|
std::chrono::seconds
|
|
parse_unsigned_time(std::istream& in)
|
|
{
|
|
using namespace std::chrono;
|
|
int x;
|
|
in >> x;
|
|
auto r = seconds{hours{x}};
|
|
if (!in.eof() && in.peek() == ':')
|
|
{
|
|
in.get();
|
|
in >> x;
|
|
r += minutes{x};
|
|
if (!in.eof() && in.peek() == ':')
|
|
{
|
|
in.get();
|
|
in >> x;
|
|
r += seconds{x};
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
static
|
|
std::chrono::seconds
|
|
parse_signed_time(std::istream& in)
|
|
{
|
|
ws(in);
|
|
auto sign = 1;
|
|
if (in.peek() == '-')
|
|
{
|
|
sign = -1;
|
|
in.get();
|
|
}
|
|
else if (in.peek() == '+')
|
|
in.get();
|
|
return sign * parse_unsigned_time(in);
|
|
}
|
|
|
|
// MonthDayTime
|
|
|
|
detail::MonthDayTime::MonthDayTime(local_seconds tp, tz timezone)
|
|
: zone_(timezone)
|
|
{
|
|
using namespace date;
|
|
const auto dp = floor<days>(tp);
|
|
const auto hms = make_time(tp - dp);
|
|
const auto ymd = year_month_day(dp);
|
|
u = ymd.month() / ymd.day();
|
|
h_ = hms.hours();
|
|
m_ = hms.minutes();
|
|
s_ = hms.seconds();
|
|
}
|
|
|
|
detail::MonthDayTime::MonthDayTime(const date::month_day& md, tz timezone)
|
|
: zone_(timezone)
|
|
{
|
|
u = md;
|
|
}
|
|
|
|
date::day
|
|
detail::MonthDayTime::day() const
|
|
{
|
|
switch (type_)
|
|
{
|
|
case month_day:
|
|
return u.month_day_.day();
|
|
case month_last_dow:
|
|
return date::day{31};
|
|
case lteq:
|
|
case gteq:
|
|
break;
|
|
}
|
|
return u.month_day_weekday_.month_day_.day();
|
|
}
|
|
|
|
date::month
|
|
detail::MonthDayTime::month() const
|
|
{
|
|
switch (type_)
|
|
{
|
|
case month_day:
|
|
return u.month_day_.month();
|
|
case month_last_dow:
|
|
return u.month_weekday_last_.month();
|
|
case lteq:
|
|
case gteq:
|
|
break;
|
|
}
|
|
return u.month_day_weekday_.month_day_.month();
|
|
}
|
|
|
|
int
|
|
detail::MonthDayTime::compare(date::year y, const MonthDayTime& x, date::year yx,
|
|
std::chrono::seconds offset, std::chrono::minutes prev_save) const
|
|
{
|
|
if (zone_ != x.zone_)
|
|
{
|
|
auto dp0 = to_sys_days(y);
|
|
auto dp1 = x.to_sys_days(yx);
|
|
if (std::abs((dp0-dp1).count()) > 1)
|
|
return dp0 < dp1 ? -1 : 1;
|
|
if (zone_ == tz::local)
|
|
{
|
|
auto tp0 = to_time_point(y) - prev_save;
|
|
if (x.zone_ == tz::utc)
|
|
tp0 -= offset;
|
|
auto tp1 = x.to_time_point(yx);
|
|
return tp0 < tp1 ? -1 : tp0 == tp1 ? 0 : 1;
|
|
}
|
|
else if (zone_ == tz::standard)
|
|
{
|
|
auto tp0 = to_time_point(y);
|
|
auto tp1 = x.to_time_point(yx);
|
|
if (x.zone_ == tz::local)
|
|
tp1 -= prev_save;
|
|
else
|
|
tp0 -= offset;
|
|
return tp0 < tp1 ? -1 : tp0 == tp1 ? 0 : 1;
|
|
}
|
|
// zone_ == tz::utc
|
|
auto tp0 = to_time_point(y);
|
|
auto tp1 = x.to_time_point(yx);
|
|
if (x.zone_ == tz::local)
|
|
tp1 -= offset + prev_save;
|
|
else
|
|
tp1 -= offset;
|
|
return tp0 < tp1 ? -1 : tp0 == tp1 ? 0 : 1;
|
|
}
|
|
auto const t0 = to_time_point(y);
|
|
auto const t1 = x.to_time_point(yx);
|
|
return t0 < t1 ? -1 : t0 == t1 ? 0 : 1;
|
|
}
|
|
|
|
sys_seconds
|
|
detail::MonthDayTime::to_sys(date::year y, std::chrono::seconds offset,
|
|
std::chrono::seconds save) const
|
|
{
|
|
using namespace date;
|
|
using namespace std::chrono;
|
|
auto until_utc = to_time_point(y);
|
|
if (zone_ == tz::standard)
|
|
until_utc -= offset;
|
|
else if (zone_ == tz::local)
|
|
until_utc -= offset + save;
|
|
return until_utc;
|
|
}
|
|
|
|
detail::MonthDayTime::U&
|
|
detail::MonthDayTime::U::operator=(const date::month_day& x)
|
|
{
|
|
month_day_ = x;
|
|
return *this;
|
|
}
|
|
|
|
detail::MonthDayTime::U&
|
|
detail::MonthDayTime::U::operator=(const date::month_weekday_last& x)
|
|
{
|
|
month_weekday_last_ = x;
|
|
return *this;
|
|
}
|
|
|
|
detail::MonthDayTime::U&
|
|
detail::MonthDayTime::U::operator=(const pair& x)
|
|
{
|
|
month_day_weekday_ = x;
|
|
return *this;
|
|
}
|
|
|
|
date::sys_days
|
|
detail::MonthDayTime::to_sys_days(date::year y) const
|
|
{
|
|
using namespace std::chrono;
|
|
using namespace date;
|
|
switch (type_)
|
|
{
|
|
case month_day:
|
|
return sys_days(y/u.month_day_);
|
|
case month_last_dow:
|
|
return sys_days(y/u.month_weekday_last_);
|
|
case lteq:
|
|
{
|
|
auto const x = y/u.month_day_weekday_.month_day_;
|
|
auto const wd1 = weekday(static_cast<sys_days>(x));
|
|
auto const wd0 = u.month_day_weekday_.weekday_;
|
|
return sys_days(x) - (wd1-wd0);
|
|
}
|
|
case gteq:
|
|
break;
|
|
}
|
|
auto const x = y/u.month_day_weekday_.month_day_;
|
|
auto const wd1 = u.month_day_weekday_.weekday_;
|
|
auto const wd0 = weekday(static_cast<sys_days>(x));
|
|
return sys_days(x) + (wd1-wd0);
|
|
}
|
|
|
|
sys_seconds
|
|
detail::MonthDayTime::to_time_point(date::year y) const
|
|
{
|
|
// Add seconds first to promote to largest rep early to prevent overflow
|
|
return to_sys_days(y) + s_ + h_ + m_;
|
|
}
|
|
|
|
void
|
|
detail::MonthDayTime::canonicalize(date::year y)
|
|
{
|
|
using namespace std::chrono;
|
|
using namespace date;
|
|
switch (type_)
|
|
{
|
|
case month_day:
|
|
return;
|
|
case month_last_dow:
|
|
{
|
|
auto const ymd = year_month_day(sys_days{y/u.month_weekday_last_});
|
|
u.month_day_ = ymd.month()/ymd.day();
|
|
type_ = month_day;
|
|
return;
|
|
}
|
|
case lteq:
|
|
{
|
|
auto const x = y/u.month_day_weekday_.month_day_;
|
|
auto const wd1 = weekday(static_cast<sys_days>(x));
|
|
auto const wd0 = u.month_day_weekday_.weekday_;
|
|
auto const ymd = year_month_day(sys_days(x) - (wd1-wd0));
|
|
u.month_day_ = ymd.month()/ymd.day();
|
|
type_ = month_day;
|
|
return;
|
|
}
|
|
case gteq:
|
|
{
|
|
auto const x = y/u.month_day_weekday_.month_day_;
|
|
auto const wd1 = u.month_day_weekday_.weekday_;
|
|
auto const wd0 = weekday(static_cast<sys_days>(x));
|
|
auto const ymd = year_month_day(sys_days(x) + (wd1-wd0));
|
|
u.month_day_ = ymd.month()/ymd.day();
|
|
type_ = month_day;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::istream&
|
|
detail::operator>>(std::istream& is, MonthDayTime& x)
|
|
{
|
|
using namespace date;
|
|
using namespace std::chrono;
|
|
x = MonthDayTime{};
|
|
if (!is.eof() && ws(is) && !is.eof() && is.peek() != '#')
|
|
{
|
|
auto m = parse_month(is);
|
|
if (!is.eof() && ws(is) && !is.eof() && is.peek() != '#')
|
|
{
|
|
if (is.peek() == 'l')
|
|
{
|
|
for (int i = 0; i < 4; ++i)
|
|
is.get();
|
|
auto dow = parse_dow(is);
|
|
x.type_ = MonthDayTime::month_last_dow;
|
|
x.u = date::month(m)/weekday(dow)[last];
|
|
}
|
|
else if (std::isalpha(is.peek()))
|
|
{
|
|
auto dow = parse_dow(is);
|
|
char c;
|
|
is >> c;
|
|
if (c == '<' || c == '>')
|
|
{
|
|
char c2;
|
|
is >> c2;
|
|
if (c2 != '=')
|
|
throw std::runtime_error(std::string("bad operator: ") + c + c2);
|
|
int d;
|
|
is >> d;
|
|
if (d < 1 || d > 31)
|
|
throw std::runtime_error(std::string("bad operator: ") + c + c2
|
|
+ std::to_string(d));
|
|
x.type_ = c == '<' ? MonthDayTime::lteq : MonthDayTime::gteq;
|
|
x.u = MonthDayTime::pair{ date::month(m) / d, date::weekday(dow) };
|
|
}
|
|
else
|
|
throw std::runtime_error(std::string("bad operator: ") + c);
|
|
}
|
|
else // if (std::isdigit(is.peek())
|
|
{
|
|
int d;
|
|
is >> d;
|
|
if (d < 1 || d > 31)
|
|
throw std::runtime_error(std::string("day of month: ")
|
|
+ std::to_string(d));
|
|
x.type_ = MonthDayTime::month_day;
|
|
x.u = date::month(m)/d;
|
|
}
|
|
if (!is.eof() && ws(is) && !is.eof() && is.peek() != '#')
|
|
{
|
|
int t;
|
|
is >> t;
|
|
x.h_ = hours{t};
|
|
if (!is.eof() && is.peek() == ':')
|
|
{
|
|
is.get();
|
|
is >> t;
|
|
x.m_ = minutes{t};
|
|
if (!is.eof() && is.peek() == ':')
|
|
{
|
|
is.get();
|
|
is >> t;
|
|
x.s_ = seconds{t};
|
|
}
|
|
}
|
|
if (!is.eof() && std::isalpha(is.peek()))
|
|
{
|
|
char c;
|
|
is >> c;
|
|
switch (c)
|
|
{
|
|
case 's':
|
|
x.zone_ = tz::standard;
|
|
break;
|
|
case 'u':
|
|
x.zone_ = tz::utc;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
x.u = month{m}/1;
|
|
}
|
|
}
|
|
return is;
|
|
}
|
|
|
|
std::ostream&
|
|
detail::operator<<(std::ostream& os, const MonthDayTime& x)
|
|
{
|
|
switch (x.type_)
|
|
{
|
|
case MonthDayTime::month_day:
|
|
os << x.u.month_day_ << " ";
|
|
break;
|
|
case MonthDayTime::month_last_dow:
|
|
os << x.u.month_weekday_last_ << " ";
|
|
break;
|
|
case MonthDayTime::lteq:
|
|
os << x.u.month_day_weekday_.weekday_ << " on or before "
|
|
<< x.u.month_day_weekday_.month_day_ << " ";
|
|
break;
|
|
case MonthDayTime::gteq:
|
|
if ((static_cast<unsigned>(x.day()) - 1) % 7 == 0)
|
|
{
|
|
os << (x.u.month_day_weekday_.month_day_.month() /
|
|
x.u.month_day_weekday_.weekday_[
|
|
(static_cast<unsigned>(x.day()) - 1)/7+1]) << " ";
|
|
}
|
|
else
|
|
{
|
|
os << x.u.month_day_weekday_.weekday_ << " on or after "
|
|
<< x.u.month_day_weekday_.month_day_ << " ";
|
|
}
|
|
break;
|
|
}
|
|
os << date::make_time(x.s_ + x.h_ + x.m_);
|
|
if (x.zone_ == tz::utc)
|
|
os << "UTC ";
|
|
else if (x.zone_ == tz::standard)
|
|
os << "STD ";
|
|
else
|
|
os << " ";
|
|
return os;
|
|
}
|
|
|
|
// Rule
|
|
|
|
detail::Rule::Rule(const std::string& s)
|
|
{
|
|
try
|
|
{
|
|
using namespace date;
|
|
using namespace std::chrono;
|
|
std::istringstream in(s);
|
|
in.exceptions(std::ios::failbit | std::ios::badbit);
|
|
std::string word;
|
|
in >> word >> name_;
|
|
int x;
|
|
ws(in);
|
|
if (std::isalpha(in.peek()))
|
|
{
|
|
in >> word;
|
|
if (word == "min")
|
|
{
|
|
starting_year_ = year::min();
|
|
}
|
|
else
|
|
throw std::runtime_error("Didn't find expected word: " + word);
|
|
}
|
|
else
|
|
{
|
|
in >> x;
|
|
starting_year_ = year{x};
|
|
}
|
|
std::ws(in);
|
|
if (std::isalpha(in.peek()))
|
|
{
|
|
in >> word;
|
|
if (word == "only")
|
|
{
|
|
ending_year_ = starting_year_;
|
|
}
|
|
else if (word == "max")
|
|
{
|
|
ending_year_ = year::max();
|
|
}
|
|
else
|
|
throw std::runtime_error("Didn't find expected word: " + word);
|
|
}
|
|
else
|
|
{
|
|
in >> x;
|
|
ending_year_ = year{x};
|
|
}
|
|
in >> word; // TYPE (always "-")
|
|
assert(word == "-");
|
|
in >> starting_at_;
|
|
save_ = duration_cast<minutes>(parse_signed_time(in));
|
|
in >> abbrev_;
|
|
if (abbrev_ == "-")
|
|
abbrev_.clear();
|
|
assert(hours{0} <= save_ && save_ <= hours{2});
|
|
}
|
|
catch (...)
|
|
{
|
|
std::cerr << s << '\n';
|
|
std::cerr << *this << '\n';
|
|
throw;
|
|
}
|
|
}
|
|
|
|
detail::Rule::Rule(const Rule& r, date::year starting_year, date::year ending_year)
|
|
: name_(r.name_)
|
|
, starting_year_(starting_year)
|
|
, ending_year_(ending_year)
|
|
, starting_at_(r.starting_at_)
|
|
, save_(r.save_)
|
|
, abbrev_(r.abbrev_)
|
|
{
|
|
}
|
|
|
|
bool
|
|
detail::operator==(const Rule& x, const Rule& y)
|
|
{
|
|
if (std::tie(x.name_, x.save_, x.starting_year_, x.ending_year_) ==
|
|
std::tie(y.name_, y.save_, y.starting_year_, y.ending_year_))
|
|
return x.month() == y.month() && x.day() == y.day();
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
detail::operator<(const Rule& x, const Rule& y)
|
|
{
|
|
using namespace std::chrono;
|
|
auto const xm = x.month();
|
|
auto const ym = y.month();
|
|
if (std::tie(x.name_, x.starting_year_, xm, x.ending_year_) <
|
|
std::tie(y.name_, y.starting_year_, ym, y.ending_year_))
|
|
return true;
|
|
if (std::tie(x.name_, x.starting_year_, xm, x.ending_year_) >
|
|
std::tie(y.name_, y.starting_year_, ym, y.ending_year_))
|
|
return false;
|
|
return x.day() < y.day();
|
|
}
|
|
|
|
bool
|
|
detail::operator==(const Rule& x, const date::year& y)
|
|
{
|
|
return x.starting_year_ <= y && y <= x.ending_year_;
|
|
}
|
|
|
|
bool
|
|
detail::operator<(const Rule& x, const date::year& y)
|
|
{
|
|
return x.ending_year_ < y;
|
|
}
|
|
|
|
bool
|
|
detail::operator==(const date::year& x, const Rule& y)
|
|
{
|
|
return y.starting_year_ <= x && x <= y.ending_year_;
|
|
}
|
|
|
|
bool
|
|
detail::operator<(const date::year& x, const Rule& y)
|
|
{
|
|
return x < y.starting_year_;
|
|
}
|
|
|
|
bool
|
|
detail::operator==(const Rule& x, const std::string& y)
|
|
{
|
|
return x.name() == y;
|
|
}
|
|
|
|
bool
|
|
detail::operator<(const Rule& x, const std::string& y)
|
|
{
|
|
return x.name() < y;
|
|
}
|
|
|
|
bool
|
|
detail::operator==(const std::string& x, const Rule& y)
|
|
{
|
|
return y.name() == x;
|
|
}
|
|
|
|
bool
|
|
detail::operator<(const std::string& x, const Rule& y)
|
|
{
|
|
return x < y.name();
|
|
}
|
|
|
|
std::ostream&
|
|
detail::operator<<(std::ostream& os, const Rule& r)
|
|
{
|
|
using namespace date;
|
|
using namespace std::chrono;
|
|
detail::save_stream<char> _(os);
|
|
os.fill(' ');
|
|
os.flags(std::ios::dec | std::ios::left);
|
|
os.width(15);
|
|
os << r.name_;
|
|
os << r.starting_year_ << " " << r.ending_year_ << " ";
|
|
os << r.starting_at_;
|
|
if (r.save_ >= minutes{0})
|
|
os << ' ';
|
|
os << date::make_time(r.save_) << " ";
|
|
os << r.abbrev_;
|
|
return os;
|
|
}
|
|
|
|
date::day
|
|
detail::Rule::day() const
|
|
{
|
|
return starting_at_.day();
|
|
}
|
|
|
|
date::month
|
|
detail::Rule::month() const
|
|
{
|
|
return starting_at_.month();
|
|
}
|
|
|
|
struct find_rule_by_name
|
|
{
|
|
bool operator()(const Rule& x, const std::string& nm) const
|
|
{
|
|
return x.name() < nm;
|
|
}
|
|
|
|
bool operator()(const std::string& nm, const Rule& x) const
|
|
{
|
|
return nm < x.name();
|
|
}
|
|
};
|
|
|
|
bool
|
|
detail::Rule::overlaps(const Rule& x, const Rule& y)
|
|
{
|
|
// assume x.starting_year_ <= y.starting_year_;
|
|
if (!(x.starting_year_ <= y.starting_year_))
|
|
{
|
|
std::cerr << x << '\n';
|
|
std::cerr << y << '\n';
|
|
assert(x.starting_year_ <= y.starting_year_);
|
|
}
|
|
if (y.starting_year_ > x.ending_year_)
|
|
return false;
|
|
return !(x.starting_year_ == y.starting_year_ && x.ending_year_ == y.ending_year_);
|
|
}
|
|
|
|
void
|
|
detail::Rule::split(std::vector<Rule>& rules, std::size_t i, std::size_t k, std::size_t& e)
|
|
{
|
|
using namespace date;
|
|
using difference_type = std::vector<Rule>::iterator::difference_type;
|
|
// rules[i].starting_year_ <= rules[k].starting_year_ &&
|
|
// rules[i].ending_year_ >= rules[k].starting_year_ &&
|
|
// (rules[i].starting_year_ != rules[k].starting_year_ ||
|
|
// rules[i].ending_year_ != rules[k].ending_year_)
|
|
assert(rules[i].starting_year_ <= rules[k].starting_year_ &&
|
|
rules[i].ending_year_ >= rules[k].starting_year_ &&
|
|
(rules[i].starting_year_ != rules[k].starting_year_ ||
|
|
rules[i].ending_year_ != rules[k].ending_year_));
|
|
if (rules[i].starting_year_ == rules[k].starting_year_)
|
|
{
|
|
if (rules[k].ending_year_ < rules[i].ending_year_)
|
|
{
|
|
rules.insert(rules.begin() + static_cast<difference_type>(k+1),
|
|
Rule(rules[i], rules[k].ending_year_ + years{1},
|
|
std::move(rules[i].ending_year_)));
|
|
++e;
|
|
rules[i].ending_year_ = rules[k].ending_year_;
|
|
}
|
|
else // rules[k].ending_year_ > rules[i].ending_year_
|
|
{
|
|
rules.insert(rules.begin() + static_cast<difference_type>(k+1),
|
|
Rule(rules[k], rules[i].ending_year_ + years{1},
|
|
std::move(rules[k].ending_year_)));
|
|
++e;
|
|
rules[k].ending_year_ = rules[i].ending_year_;
|
|
}
|
|
}
|
|
else // rules[i].starting_year_ < rules[k].starting_year_
|
|
{
|
|
if (rules[k].ending_year_ < rules[i].ending_year_)
|
|
{
|
|
rules.insert(rules.begin() + static_cast<difference_type>(k),
|
|
Rule(rules[i], rules[k].starting_year_, rules[k].ending_year_));
|
|
++k;
|
|
rules.insert(rules.begin() + static_cast<difference_type>(k+1),
|
|
Rule(rules[i], rules[k].ending_year_ + years{1},
|
|
std::move(rules[i].ending_year_)));
|
|
rules[i].ending_year_ = rules[k].starting_year_ - years{1};
|
|
e += 2;
|
|
}
|
|
else if (rules[k].ending_year_ > rules[i].ending_year_)
|
|
{
|
|
rules.insert(rules.begin() + static_cast<difference_type>(k),
|
|
Rule(rules[i], rules[k].starting_year_, rules[i].ending_year_));
|
|
++k;
|
|
rules.insert(rules.begin() + static_cast<difference_type>(k+1),
|
|
Rule(rules[k], rules[i].ending_year_ + years{1},
|
|
std::move(rules[k].ending_year_)));
|
|
e += 2;
|
|
rules[k].ending_year_ = std::move(rules[i].ending_year_);
|
|
rules[i].ending_year_ = rules[k].starting_year_ - years{1};
|
|
}
|
|
else // rules[k].ending_year_ == rules[i].ending_year_
|
|
{
|
|
rules.insert(rules.begin() + static_cast<difference_type>(k),
|
|
Rule(rules[i], rules[k].starting_year_,
|
|
std::move(rules[i].ending_year_)));
|
|
++k;
|
|
++e;
|
|
rules[i].ending_year_ = rules[k].starting_year_ - years{1};
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
detail::Rule::split_overlaps(std::vector<Rule>& rules, std::size_t i, std::size_t& e)
|
|
{
|
|
using difference_type = std::vector<Rule>::iterator::difference_type;
|
|
auto j = i;
|
|
for (; i + 1 < e; ++i)
|
|
{
|
|
for (auto k = i + 1; k < e; ++k)
|
|
{
|
|
if (overlaps(rules[i], rules[k]))
|
|
{
|
|
split(rules, i, k, e);
|
|
std::sort(rules.begin() + static_cast<difference_type>(i),
|
|
rules.begin() + static_cast<difference_type>(e));
|
|
}
|
|
}
|
|
}
|
|
for (; j < e; ++j)
|
|
{
|
|
if (rules[j].starting_year() == rules[j].ending_year())
|
|
rules[j].starting_at_.canonicalize(rules[j].starting_year());
|
|
}
|
|
}
|
|
|
|
void
|
|
detail::Rule::split_overlaps(std::vector<Rule>& rules)
|
|
{
|
|
using difference_type = std::vector<Rule>::iterator::difference_type;
|
|
for (std::size_t i = 0; i < rules.size();)
|
|
{
|
|
auto e = static_cast<std::size_t>(std::upper_bound(
|
|
rules.cbegin()+static_cast<difference_type>(i), rules.cend(), rules[i].name(),
|
|
[](const std::string& nm, const Rule& x)
|
|
{
|
|
return nm < x.name();
|
|
}) - rules.cbegin());
|
|
split_overlaps(rules, i, e);
|
|
auto first_rule = rules.begin() + static_cast<difference_type>(i);
|
|
auto last_rule = rules.begin() + static_cast<difference_type>(e);
|
|
auto t = std::lower_bound(first_rule, last_rule, min_year);
|
|
if (t > first_rule+1)
|
|
{
|
|
if (t == last_rule || t->starting_year() >= min_year)
|
|
--t;
|
|
auto d = static_cast<std::size_t>(t - first_rule);
|
|
rules.erase(first_rule, t);
|
|
e -= d;
|
|
}
|
|
first_rule = rules.begin() + static_cast<difference_type>(i);
|
|
last_rule = rules.begin() + static_cast<difference_type>(e);
|
|
t = std::upper_bound(first_rule, last_rule, max_year);
|
|
if (t != last_rule)
|
|
{
|
|
auto d = static_cast<std::size_t>(last_rule - t);
|
|
rules.erase(t, last_rule);
|
|
e -= d;
|
|
}
|
|
i = e;
|
|
}
|
|
rules.shrink_to_fit();
|
|
}
|
|
|
|
// time_zone
|
|
|
|
detail::zonelet::~zonelet()
|
|
{
|
|
#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
|
|
using minutes = std::chrono::minutes;
|
|
using string = std::string;
|
|
if (tag_ == has_save)
|
|
u.save_.~minutes();
|
|
else
|
|
u.rule_.~string();
|
|
#endif
|
|
}
|
|
|
|
detail::zonelet::zonelet()
|
|
{
|
|
#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
|
|
::new(&u.rule_) std::string();
|
|
#endif
|
|
}
|
|
|
|
detail::zonelet::zonelet(const zonelet& i)
|
|
: gmtoff_(i.gmtoff_)
|
|
, tag_(i.tag_)
|
|
, format_(i.format_)
|
|
, until_year_(i.until_year_)
|
|
, until_date_(i.until_date_)
|
|
, until_utc_(i.until_utc_)
|
|
, until_std_(i.until_std_)
|
|
, until_loc_(i.until_loc_)
|
|
, initial_save_(i.initial_save_)
|
|
, initial_abbrev_(i.initial_abbrev_)
|
|
, first_rule_(i.first_rule_)
|
|
, last_rule_(i.last_rule_)
|
|
{
|
|
#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
|
|
if (tag_ == has_save)
|
|
::new(&u.save_) std::chrono::minutes(i.u.save_);
|
|
else
|
|
::new(&u.rule_) std::string(i.u.rule_);
|
|
#else
|
|
if (tag_ == has_save)
|
|
u.save_ = i.u.save_;
|
|
else
|
|
u.rule_ = i.u.rule_;
|
|
#endif
|
|
}
|
|
|
|
time_zone::time_zone(const std::string& s, detail::undocumented)
|
|
#if LAZY_INIT
|
|
: adjusted_(new std::once_flag{})
|
|
#endif
|
|
{
|
|
try
|
|
{
|
|
using namespace date;
|
|
std::istringstream in(s);
|
|
in.exceptions(std::ios::failbit | std::ios::badbit);
|
|
std::string word;
|
|
in >> word >> name_;
|
|
parse_info(in);
|
|
}
|
|
catch (...)
|
|
{
|
|
std::cerr << s << '\n';
|
|
std::cerr << *this << '\n';
|
|
zonelets_.pop_back();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void
|
|
time_zone::add(const std::string& s)
|
|
{
|
|
try
|
|
{
|
|
std::istringstream in(s);
|
|
in.exceptions(std::ios::failbit | std::ios::badbit);
|
|
ws(in);
|
|
if (!in.eof() && in.peek() != '#')
|
|
parse_info(in);
|
|
}
|
|
catch (...)
|
|
{
|
|
std::cerr << s << '\n';
|
|
std::cerr << *this << '\n';
|
|
zonelets_.pop_back();
|
|
throw;
|
|
}
|
|
}
|
|
|
|
void
|
|
time_zone::parse_info(std::istream& in)
|
|
{
|
|
using namespace date;
|
|
using namespace std::chrono;
|
|
zonelets_.emplace_back();
|
|
auto& zonelet = zonelets_.back();
|
|
zonelet.gmtoff_ = parse_signed_time(in);
|
|
in >> zonelet.u.rule_;
|
|
if (zonelet.u.rule_ == "-")
|
|
zonelet.u.rule_.clear();
|
|
in >> zonelet.format_;
|
|
if (!in.eof())
|
|
ws(in);
|
|
if (in.eof() || in.peek() == '#')
|
|
{
|
|
zonelet.until_year_ = year::max();
|
|
zonelet.until_date_ = MonthDayTime(max_day, tz::utc);
|
|
}
|
|
else
|
|
{
|
|
int y;
|
|
in >> y;
|
|
zonelet.until_year_ = year{y};
|
|
in >> zonelet.until_date_;
|
|
zonelet.until_date_.canonicalize(zonelet.until_year_);
|
|
}
|
|
if ((zonelet.until_year_ < min_year) ||
|
|
(zonelets_.size() > 1 && zonelets_.end()[-2].until_year_ > max_year))
|
|
zonelets_.pop_back();
|
|
}
|
|
|
|
// Find the rule that comes chronologically before Rule r. For multi-year rules,
|
|
// y specifies which rules in r. For single year rules, y is assumed to be equal
|
|
// to the year specified by r.
|
|
// Returns a pointer to the chronologically previous rule, and the year within
|
|
// that rule. If there is no previous rule, returns nullptr and year::min().
|
|
// Preconditions:
|
|
// r->starting_year() <= y && y <= r->ending_year()
|
|
static
|
|
std::pair<const Rule*, date::year>
|
|
find_previous_rule(const Rule* r, date::year y)
|
|
{
|
|
using namespace date;
|
|
auto const& rules = get_tzdb().rules;
|
|
if (y == r->starting_year())
|
|
{
|
|
if (r == &rules.front() || r->name() != r[-1].name())
|
|
return {nullptr, year::min()};
|
|
--r;
|
|
if (y == r->starting_year())
|
|
return {r, y};
|
|
return {r, r->ending_year()};
|
|
}
|
|
if (r == &rules.front() || r->name() != r[-1].name() ||
|
|
r[-1].starting_year() < r->starting_year())
|
|
{
|
|
while (r < &rules.back() && r->name() == r[1].name() &&
|
|
r->starting_year() == r[1].starting_year())
|
|
++r;
|
|
return {r, --y};
|
|
}
|
|
--r;
|
|
return {r, y};
|
|
}
|
|
|
|
// Find the rule that comes chronologically after Rule r. For multi-year rules,
|
|
// y specifies which rules in r. For single year rules, y is assumed to be equal
|
|
// to the year specified by r.
|
|
// Returns a pointer to the chronologically next rule, and the year within
|
|
// that rule. If there is no next rule, return a pointer to a defaulted rule
|
|
// and y+1.
|
|
// Preconditions:
|
|
// first <= r && r < last && r->starting_year() <= y && y <= r->ending_year()
|
|
// [first, last) all have the same name
|
|
static
|
|
std::pair<const Rule*, date::year>
|
|
find_next_rule(const Rule* first_rule, const Rule* last_rule, const Rule* r, date::year y)
|
|
{
|
|
using namespace date;
|
|
if (y == r->ending_year())
|
|
{
|
|
if (r == last_rule-1)
|
|
return {nullptr, year::max()};
|
|
++r;
|
|
if (y == r->ending_year())
|
|
return {r, y};
|
|
return {r, r->starting_year()};
|
|
}
|
|
if (r == last_rule-1 || r->ending_year() < r[1].ending_year())
|
|
{
|
|
while (r > first_rule && r->starting_year() == r[-1].starting_year())
|
|
--r;
|
|
return {r, ++y};
|
|
}
|
|
++r;
|
|
return {r, y};
|
|
}
|
|
|
|
// Find the rule that comes chronologically after Rule r. For multi-year rules,
|
|
// y specifies which rules in r. For single year rules, y is assumed to be equal
|
|
// to the year specified by r.
|
|
// Returns a pointer to the chronologically next rule, and the year within
|
|
// that rule. If there is no next rule, return nullptr and year::max().
|
|
// Preconditions:
|
|
// r->starting_year() <= y && y <= r->ending_year()
|
|
static
|
|
std::pair<const Rule*, date::year>
|
|
find_next_rule(const Rule* r, date::year y)
|
|
{
|
|
using namespace date;
|
|
auto const& rules = get_tzdb().rules;
|
|
if (y == r->ending_year())
|
|
{
|
|
if (r == &rules.back() || r->name() != r[1].name())
|
|
return {nullptr, year::max()};
|
|
++r;
|
|
if (y == r->ending_year())
|
|
return {r, y};
|
|
return {r, r->starting_year()};
|
|
}
|
|
if (r == &rules.back() || r->name() != r[1].name() ||
|
|
r->ending_year() < r[1].ending_year())
|
|
{
|
|
while (r > &rules.front() && r->name() == r[-1].name() &&
|
|
r->starting_year() == r[-1].starting_year())
|
|
--r;
|
|
return {r, ++y};
|
|
}
|
|
++r;
|
|
return {r, y};
|
|
}
|
|
|
|
static
|
|
const Rule*
|
|
find_first_std_rule(const std::pair<const Rule*, const Rule*>& eqr)
|
|
{
|
|
auto r = eqr.first;
|
|
auto ry = r->starting_year();
|
|
while (r->save() != std::chrono::minutes{0})
|
|
{
|
|
std::tie(r, ry) = find_next_rule(eqr.first, eqr.second, r, ry);
|
|
if (r == nullptr)
|
|
throw std::runtime_error("Could not find standard offset in rule "
|
|
+ eqr.first->name());
|
|
}
|
|
return r;
|
|
}
|
|
|
|
static
|
|
std::pair<const Rule*, date::year>
|
|
find_rule_for_zone(const std::pair<const Rule*, const Rule*>& eqr,
|
|
const date::year& y, const std::chrono::seconds& offset,
|
|
const MonthDayTime& mdt)
|
|
{
|
|
assert(eqr.first != nullptr);
|
|
assert(eqr.second != nullptr);
|
|
|
|
using namespace std::chrono;
|
|
using namespace date;
|
|
auto r = eqr.first;
|
|
auto ry = r->starting_year();
|
|
auto prev_save = minutes{0};
|
|
auto prev_year = year::min();
|
|
const Rule* prev_rule = nullptr;
|
|
while (r != nullptr)
|
|
{
|
|
if (mdt.compare(y, r->mdt(), ry, offset, prev_save) <= 0)
|
|
break;
|
|
prev_rule = r;
|
|
prev_year = ry;
|
|
prev_save = prev_rule->save();
|
|
std::tie(r, ry) = find_next_rule(eqr.first, eqr.second, r, ry);
|
|
}
|
|
return {prev_rule, prev_year};
|
|
}
|
|
|
|
static
|
|
std::pair<const Rule*, date::year>
|
|
find_rule_for_zone(const std::pair<const Rule*, const Rule*>& eqr,
|
|
const sys_seconds& tp_utc,
|
|
const local_seconds& tp_std,
|
|
const local_seconds& tp_loc)
|
|
{
|
|
using namespace std::chrono;
|
|
using namespace date;
|
|
auto r = eqr.first;
|
|
auto ry = r->starting_year();
|
|
auto prev_save = minutes{0};
|
|
auto prev_year = year::min();
|
|
const Rule* prev_rule = nullptr;
|
|
while (r != nullptr)
|
|
{
|
|
bool found;
|
|
switch (r->mdt().zone())
|
|
{
|
|
case tz::utc:
|
|
found = tp_utc < r->mdt().to_time_point(ry);
|
|
break;
|
|
case tz::standard:
|
|
found = sys_seconds{tp_std.time_since_epoch()} < r->mdt().to_time_point(ry);
|
|
break;
|
|
case tz::local:
|
|
found = sys_seconds{tp_loc.time_since_epoch()} < r->mdt().to_time_point(ry);
|
|
break;
|
|
}
|
|
if (found)
|
|
break;
|
|
prev_rule = r;
|
|
prev_year = ry;
|
|
prev_save = prev_rule->save();
|
|
std::tie(r, ry) = find_next_rule(eqr.first, eqr.second, r, ry);
|
|
}
|
|
return {prev_rule, prev_year};
|
|
}
|
|
|
|
static
|
|
sys_info
|
|
find_rule(const std::pair<const Rule*, date::year>& first_rule,
|
|
const std::pair<const Rule*, date::year>& last_rule,
|
|
const date::year& y, const std::chrono::seconds& offset,
|
|
const MonthDayTime& mdt, const std::chrono::minutes& initial_save,
|
|
const std::string& initial_abbrev)
|
|
{
|
|
using namespace std::chrono;
|
|
using namespace date;
|
|
auto r = first_rule.first;
|
|
auto ry = first_rule.second;
|
|
sys_info x{sys_days(year::min()/min_day), sys_days(year::max()/max_day),
|
|
seconds{0}, initial_save, initial_abbrev};
|
|
while (r != nullptr)
|
|
{
|
|
auto tr = r->mdt().to_sys(ry, offset, x.save);
|
|
auto tx = mdt.to_sys(y, offset, x.save);
|
|
// Find last rule where tx >= tr
|
|
if (tx <= tr || (r == last_rule.first && ry == last_rule.second))
|
|
{
|
|
if (tx < tr && r == first_rule.first && ry == first_rule.second)
|
|
{
|
|
x.end = r->mdt().to_sys(ry, offset, x.save);
|
|
break;
|
|
}
|
|
if (tx < tr)
|
|
{
|
|
std::tie(r, ry) = find_previous_rule(r, ry); // can't return nullptr for r
|
|
assert(r != nullptr);
|
|
}
|
|
// r != nullptr && tx >= tr (if tr were to be recomputed)
|
|
auto prev_save = initial_save;
|
|
if (!(r == first_rule.first && ry == first_rule.second))
|
|
prev_save = find_previous_rule(r, ry).first->save();
|
|
x.begin = r->mdt().to_sys(ry, offset, prev_save);
|
|
x.save = r->save();
|
|
x.abbrev = r->abbrev();
|
|
if (!(r == last_rule.first && ry == last_rule.second))
|
|
{
|
|
std::tie(r, ry) = find_next_rule(r, ry); // can't return nullptr for r
|
|
assert(r != nullptr);
|
|
x.end = r->mdt().to_sys(ry, offset, x.save);
|
|
}
|
|
else
|
|
x.end = sys_days(year::max()/max_day);
|
|
break;
|
|
}
|
|
x.save = r->save();
|
|
std::tie(r, ry) = find_next_rule(r, ry); // Can't return nullptr for r
|
|
assert(r != nullptr);
|
|
}
|
|
return x;
|
|
}
|
|
|
|
void
|
|
time_zone::adjust_infos(const std::vector<Rule>& rules)
|
|
{
|
|
using namespace std::chrono;
|
|
using namespace date;
|
|
const zonelet* prev_zonelet = nullptr;
|
|
for (auto& z : zonelets_)
|
|
{
|
|
std::pair<const Rule*, const Rule*> eqr{};
|
|
std::istringstream in;
|
|
in.exceptions(std::ios::failbit | std::ios::badbit);
|
|
// Classify info as rule-based, has save, or neither
|
|
if (!z.u.rule_.empty())
|
|
{
|
|
// Find out if this zonelet has a rule or a save
|
|
eqr = std::equal_range(rules.data(), rules.data() + rules.size(), z.u.rule_);
|
|
if (eqr.first == eqr.second)
|
|
{
|
|
// The rule doesn't exist. Assume this is a save
|
|
try
|
|
{
|
|
using namespace std::chrono;
|
|
using string = std::string;
|
|
in.str(z.u.rule_);
|
|
auto tmp = duration_cast<minutes>(parse_signed_time(in));
|
|
#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
|
|
z.u.rule_.~string();
|
|
z.tag_ = zonelet::has_save;
|
|
::new(&z.u.save_) minutes(tmp);
|
|
#else
|
|
z.u.rule_.clear();
|
|
z.tag_ = zonelet::has_save;
|
|
z.u.save_ = tmp;
|
|
#endif
|
|
}
|
|
catch (...)
|
|
{
|
|
std::cerr << name_ << " : " << z.u.rule_ << '\n';
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This zone::zonelet has no rule and no save
|
|
z.tag_ = zonelet::is_empty;
|
|
}
|
|
|
|
minutes final_save{0};
|
|
if (z.tag_ == zonelet::has_save)
|
|
{
|
|
final_save = z.u.save_;
|
|
}
|
|
else if (z.tag_ == zonelet::has_rule)
|
|
{
|
|
z.last_rule_ = find_rule_for_zone(eqr, z.until_year_, z.gmtoff_,
|
|
z.until_date_);
|
|
if (z.last_rule_.first != nullptr)
|
|
final_save = z.last_rule_.first->save();
|
|
}
|
|
z.until_utc_ = z.until_date_.to_sys(z.until_year_, z.gmtoff_, final_save);
|
|
z.until_std_ = local_seconds{z.until_utc_.time_since_epoch()} + z.gmtoff_;
|
|
z.until_loc_ = z.until_std_ + final_save;
|
|
|
|
if (z.tag_ == zonelet::has_rule)
|
|
{
|
|
if (prev_zonelet != nullptr)
|
|
{
|
|
z.first_rule_ = find_rule_for_zone(eqr, prev_zonelet->until_utc_,
|
|
prev_zonelet->until_std_,
|
|
prev_zonelet->until_loc_);
|
|
if (z.first_rule_.first != nullptr)
|
|
{
|
|
z.initial_save_ = z.first_rule_.first->save();
|
|
z.initial_abbrev_ = z.first_rule_.first->abbrev();
|
|
if (z.first_rule_ != z.last_rule_)
|
|
{
|
|
z.first_rule_ = find_next_rule(eqr.first, eqr.second,
|
|
z.first_rule_.first,
|
|
z.first_rule_.second);
|
|
}
|
|
else
|
|
{
|
|
z.first_rule_ = std::make_pair(nullptr, year::min());
|
|
z.last_rule_ = std::make_pair(nullptr, year::max());
|
|
}
|
|
}
|
|
}
|
|
if (z.first_rule_.first == nullptr && z.last_rule_.first != nullptr)
|
|
{
|
|
z.first_rule_ = std::make_pair(eqr.first, eqr.first->starting_year());
|
|
z.initial_abbrev_ = find_first_std_rule(eqr)->abbrev();
|
|
}
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
if (z.first_rule_.first == nullptr)
|
|
{
|
|
assert(z.first_rule_.second == year::min());
|
|
assert(z.last_rule_.first == nullptr);
|
|
assert(z.last_rule_.second == year::max());
|
|
}
|
|
else
|
|
{
|
|
assert(z.last_rule_.first != nullptr);
|
|
}
|
|
#endif
|
|
prev_zonelet = &z;
|
|
}
|
|
}
|
|
|
|
static
|
|
std::string
|
|
format_abbrev(std::string format, const std::string& variable, std::chrono::seconds off,
|
|
std::chrono::minutes save)
|
|
{
|
|
using namespace std::chrono;
|
|
auto k = format.find("%s");
|
|
if (k != std::string::npos)
|
|
{
|
|
format.replace(k, 2, variable);
|
|
}
|
|
else
|
|
{
|
|
k = format.find('/');
|
|
if (k != std::string::npos)
|
|
{
|
|
if (save == minutes{0})
|
|
format.erase(k);
|
|
else
|
|
format.erase(0, k+1);
|
|
}
|
|
else
|
|
{
|
|
k = format.find("%z");
|
|
if (k != std::string::npos)
|
|
{
|
|
std::string temp;
|
|
if (off < seconds{0})
|
|
{
|
|
temp = '-';
|
|
off = -off;
|
|
}
|
|
else
|
|
temp = '+';
|
|
auto h = floor<hours>(off);
|
|
off -= h;
|
|
if (h < hours{10})
|
|
temp += '0';
|
|
temp += std::to_string(h.count());
|
|
if (off > seconds{0})
|
|
{
|
|
auto m = floor<minutes>(off);
|
|
off -= m;
|
|
if (m < minutes{10})
|
|
temp += '0';
|
|
temp += std::to_string(m.count());
|
|
if (off > seconds{0})
|
|
{
|
|
if (off < seconds{10})
|
|
temp += '0';
|
|
temp += std::to_string(off.count());
|
|
}
|
|
}
|
|
format.replace(k, 2, temp);
|
|
}
|
|
}
|
|
}
|
|
return format;
|
|
}
|
|
|
|
sys_info
|
|
time_zone::get_info_impl(sys_seconds tp) const
|
|
{
|
|
return get_info_impl(tp, static_cast<int>(tz::utc));
|
|
}
|
|
|
|
local_info
|
|
time_zone::get_info_impl(local_seconds tp) const
|
|
{
|
|
using namespace std::chrono;
|
|
local_info i{};
|
|
i.first = get_info_impl(sys_seconds{tp.time_since_epoch()}, static_cast<int>(tz::local));
|
|
auto tps = sys_seconds{(tp - i.first.offset).time_since_epoch()};
|
|
if (tps < i.first.begin)
|
|
{
|
|
i.second = std::move(i.first);
|
|
i.first = get_info_impl(i.second.begin - seconds{1}, static_cast<int>(tz::utc));
|
|
i.result = local_info::nonexistent;
|
|
}
|
|
else if (i.first.end - tps <= days{1})
|
|
{
|
|
i.second = get_info_impl(i.first.end, static_cast<int>(tz::utc));
|
|
tps = sys_seconds{(tp - i.second.offset).time_since_epoch()};
|
|
if (tps >= i.second.begin)
|
|
i.result = local_info::ambiguous;
|
|
else
|
|
i.second = {};
|
|
}
|
|
return i;
|
|
}
|
|
|
|
sys_info
|
|
time_zone::get_info_impl(sys_seconds tp, int tz_int) const
|
|
{
|
|
using namespace std::chrono;
|
|
using namespace date;
|
|
tz timezone = static_cast<tz>(tz_int);
|
|
assert(timezone != tz::standard);
|
|
auto y = year_month_day(floor<days>(tp)).year();
|
|
if (y < min_year || y > max_year)
|
|
throw std::runtime_error("The year " + std::to_string(static_cast<int>(y)) +
|
|
" is out of range:[" + std::to_string(static_cast<int>(min_year)) + ", "
|
|
+ std::to_string(static_cast<int>(max_year)) + "]");
|
|
#if LAZY_INIT
|
|
std::call_once(*adjusted_,
|
|
[this]()
|
|
{
|
|
const_cast<time_zone*>(this)->adjust_infos(get_tzdb().rules);
|
|
});
|
|
#endif
|
|
auto i = std::upper_bound(zonelets_.begin(), zonelets_.end(), tp,
|
|
[timezone](sys_seconds t, const zonelet& zl)
|
|
{
|
|
return timezone == tz::utc ? t < zl.until_utc_ :
|
|
t < sys_seconds{zl.until_loc_.time_since_epoch()};
|
|
});
|
|
|
|
sys_info r{};
|
|
if (i != zonelets_.end())
|
|
{
|
|
if (i->tag_ == zonelet::has_save)
|
|
{
|
|
if (i != zonelets_.begin())
|
|
r.begin = i[-1].until_utc_;
|
|
else
|
|
r.begin = sys_days(year::min()/min_day);
|
|
r.end = i->until_utc_;
|
|
r.offset = i->gmtoff_ + i->u.save_;
|
|
r.save = i->u.save_;
|
|
}
|
|
else if (i->u.rule_.empty())
|
|
{
|
|
if (i != zonelets_.begin())
|
|
r.begin = i[-1].until_utc_;
|
|
else
|
|
r.begin = sys_days(year::min()/min_day);
|
|
r.end = i->until_utc_;
|
|
r.offset = i->gmtoff_;
|
|
}
|
|
else
|
|
{
|
|
r = find_rule(i->first_rule_, i->last_rule_, y, i->gmtoff_,
|
|
MonthDayTime(local_seconds{tp.time_since_epoch()}, timezone),
|
|
i->initial_save_, i->initial_abbrev_);
|
|
r.offset = i->gmtoff_ + r.save;
|
|
if (i != zonelets_.begin() && r.begin < i[-1].until_utc_)
|
|
r.begin = i[-1].until_utc_;
|
|
if (r.end > i->until_utc_)
|
|
r.end = i->until_utc_;
|
|
}
|
|
r.abbrev = format_abbrev(i->format_, r.abbrev, r.offset, r.save);
|
|
assert(r.begin < r.end);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
std::ostream&
|
|
operator<<(std::ostream& os, const time_zone& z)
|
|
{
|
|
using namespace date;
|
|
using namespace std::chrono;
|
|
detail::save_stream<char> _(os);
|
|
os.fill(' ');
|
|
os.flags(std::ios::dec | std::ios::left);
|
|
#if LAZY_INIT
|
|
std::call_once(*z.adjusted_,
|
|
[&z]()
|
|
{
|
|
const_cast<time_zone&>(z).adjust_infos(get_tzdb().rules);
|
|
});
|
|
#endif
|
|
os.width(35);
|
|
os << z.name_;
|
|
std::string indent;
|
|
for (auto const& s : z.zonelets_)
|
|
{
|
|
os << indent;
|
|
if (s.gmtoff_ >= seconds{0})
|
|
os << ' ';
|
|
os << make_time(s.gmtoff_) << " ";
|
|
os.width(15);
|
|
if (s.tag_ != zonelet::has_save)
|
|
os << s.u.rule_;
|
|
else
|
|
{
|
|
std::ostringstream tmp;
|
|
tmp << make_time(s.u.save_);
|
|
os << tmp.str();
|
|
}
|
|
os.width(8);
|
|
os << s.format_ << " ";
|
|
os << s.until_year_ << ' ' << s.until_date_;
|
|
os << " " << s.until_utc_ << " UTC";
|
|
os << " " << s.until_std_ << " STD";
|
|
os << " " << s.until_loc_;
|
|
os << " " << make_time(s.initial_save_);
|
|
os << " " << s.initial_abbrev_;
|
|
if (s.first_rule_.first != nullptr)
|
|
os << " {" << *s.first_rule_.first << ", " << s.first_rule_.second << '}';
|
|
else
|
|
os << " {" << "nullptr" << ", " << s.first_rule_.second << '}';
|
|
if (s.last_rule_.first != nullptr)
|
|
os << " {" << *s.last_rule_.first << ", " << s.last_rule_.second << '}';
|
|
else
|
|
os << " {" << "nullptr" << ", " << s.last_rule_.second << '}';
|
|
os << '\n';
|
|
if (indent.empty())
|
|
indent = std::string(35, ' ');
|
|
}
|
|
return os;
|
|
}
|
|
|
|
// link
|
|
|
|
link::link(const std::string& s)
|
|
{
|
|
using namespace date;
|
|
std::istringstream in(s);
|
|
in.exceptions(std::ios::failbit | std::ios::badbit);
|
|
std::string word;
|
|
in >> word >> target_ >> name_;
|
|
}
|
|
|
|
std::ostream&
|
|
operator<<(std::ostream& os, const link& x)
|
|
{
|
|
using namespace date;
|
|
detail::save_stream<char> _(os);
|
|
os.fill(' ');
|
|
os.flags(std::ios::dec | std::ios::left);
|
|
os.width(35);
|
|
return os << x.name_ << " --> " << x.target_;
|
|
}
|
|
|
|
// leap
|
|
|
|
leap::leap(const std::string& s, detail::undocumented)
|
|
{
|
|
using namespace date;
|
|
std::istringstream in(s);
|
|
in.exceptions(std::ios::failbit | std::ios::badbit);
|
|
std::string word;
|
|
int y;
|
|
MonthDayTime date;
|
|
in >> word >> y >> date;
|
|
date_ = date.to_time_point(year(y));
|
|
}
|
|
|
|
std::ostream&
|
|
operator<<(std::ostream& os, const leap& x)
|
|
{
|
|
using namespace date;
|
|
return os << x.date_ << " +";
|
|
}
|
|
|
|
static
|
|
bool
|
|
file_exists(const std::string& filename)
|
|
{
|
|
#ifdef _WIN32
|
|
return ::_access(filename.c_str(), 0) == 0;
|
|
#else
|
|
return ::access(filename.c_str(), F_OK) == 0;
|
|
#endif
|
|
}
|
|
|
|
#if HAS_REMOTE_API
|
|
|
|
// CURL tools
|
|
|
|
static
|
|
int
|
|
curl_global()
|
|
{
|
|
if (::curl_global_init(CURL_GLOBAL_DEFAULT) != 0)
|
|
throw std::runtime_error("CURL global initialization failed");
|
|
return 0;
|
|
}
|
|
|
|
static const auto curl_delete = [](CURL* p) {::curl_easy_cleanup(p);};
|
|
|
|
static
|
|
std::unique_ptr<CURL, decltype(curl_delete)>
|
|
curl_init()
|
|
{
|
|
static const auto curl_is_now_initiailized = curl_global();
|
|
(void)curl_is_now_initiailized;
|
|
return std::unique_ptr<CURL, decltype(curl_delete)>{::curl_easy_init(), curl_delete};
|
|
}
|
|
|
|
static
|
|
bool
|
|
download_to_string(const std::string& url, std::string& str)
|
|
{
|
|
str.clear();
|
|
auto curl = curl_init();
|
|
if (!curl)
|
|
return false;
|
|
std::string version;
|
|
curl_easy_setopt(curl.get(), CURLOPT_URL, url.c_str());
|
|
curl_write_callback write_cb = [](char* contents, std::size_t size, std::size_t nmemb,
|
|
void* userp) -> std::size_t
|
|
{
|
|
auto& str = *static_cast<std::string*>(userp);
|
|
auto realsize = size * nmemb;
|
|
str.append(contents, realsize);
|
|
return realsize;
|
|
};
|
|
curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, write_cb);
|
|
curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &str);
|
|
auto res = curl_easy_perform(curl.get());
|
|
return (res == CURLE_OK);
|
|
}
|
|
|
|
namespace
|
|
{
|
|
enum class download_file_options { binary, text };
|
|
}
|
|
|
|
static
|
|
bool
|
|
download_to_file(const std::string& url, const std::string& local_filename,
|
|
download_file_options opts)
|
|
{
|
|
auto curl = curl_init();
|
|
if (!curl)
|
|
return false;
|
|
curl_easy_setopt(curl.get(), CURLOPT_URL, url.c_str());
|
|
curl_write_callback write_cb = [](char* contents, std::size_t size, std::size_t nmemb,
|
|
void* userp) -> std::size_t
|
|
{
|
|
auto& of = *static_cast<std::ofstream*>(userp);
|
|
auto realsize = size * nmemb;
|
|
of.write(contents, realsize);
|
|
return realsize;
|
|
};
|
|
curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, write_cb);
|
|
decltype(curl_easy_perform(curl.get())) res;
|
|
{
|
|
std::ofstream of(local_filename,
|
|
opts == download_file_options::binary ?
|
|
std::ofstream::out | std::ofstream::binary :
|
|
std::ofstream::out);
|
|
of.exceptions(std::ios::badbit);
|
|
curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &of);
|
|
res = curl_easy_perform(curl.get());
|
|
}
|
|
return res == CURLE_OK;
|
|
}
|
|
|
|
std::string
|
|
remote_version()
|
|
{
|
|
std::string version;
|
|
std::string str;
|
|
if (download_to_string("http://www.iana.org/time-zones", str))
|
|
{
|
|
CONSTDATA char db[] = "/time-zones/repository/releases/tzdata";
|
|
CONSTDATA auto db_size = sizeof(db) - 1;
|
|
auto p = str.find(db, 0, db_size);
|
|
const int ver_str_len = 5;
|
|
if (p != std::string::npos && p + (db_size + ver_str_len) <= str.size())
|
|
version = str.substr(p + db_size, ver_str_len);
|
|
}
|
|
return version;
|
|
}
|
|
|
|
bool
|
|
remote_download(const std::string& version)
|
|
{
|
|
assert(!version.empty());
|
|
auto url = "http://www.iana.org/time-zones/repository/releases/tzdata" + version +
|
|
".tar.gz";
|
|
bool result = download_to_file(url, get_download_gz_file(version),
|
|
download_file_options::binary);
|
|
#ifdef TIMEZONE_MAPPING
|
|
if (result)
|
|
{
|
|
auto mapping_file = get_download_mapping_file(version);
|
|
result = download_to_file("http://unicode.org/repos/cldr/trunk/common/"
|
|
"supplemental/windowsZones.xml",
|
|
mapping_file, download_file_options::text);
|
|
}
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
// TODO! Using system() create a process and a console window.
|
|
// This is useful to see what errors may occur but is slow and distracting.
|
|
// Consider implementing this functionality more directly, such as
|
|
// using _mkdir and CreateProcess etc.
|
|
// But use the current means now as matches Unix implementations and while
|
|
// in proof of concept / testing phase.
|
|
// TODO! Use <filesystem> eventually.
|
|
static
|
|
bool
|
|
remove_folder_and_subfolders(const std::string& folder)
|
|
{
|
|
#ifdef _WIN32
|
|
# if USE_SHELL_API
|
|
// Delete the folder contents by deleting the folder.
|
|
std::string cmd = "rd /s /q \"";
|
|
cmd += folder;
|
|
cmd += '\"';
|
|
return std::system(cmd.c_str()) == EXIT_SUCCESS;
|
|
# else // !USE_SHELL_API
|
|
// Create a buffer containing the path to delete. It must be terminated
|
|
// by two nuls. Who designs these API's...
|
|
std::vector<char> from;
|
|
from.assign(folder.begin(), folder.end());
|
|
from.push_back('\0');
|
|
from.push_back('\0');
|
|
SHFILEOPSTRUCT fo{}; // Zero initialize.
|
|
fo.wFunc = FO_DELETE;
|
|
fo.pFrom = from.data();
|
|
fo.fFlags = FOF_NO_UI;
|
|
int ret = SHFileOperation(&fo);
|
|
if (ret == 0 && !fo.fAnyOperationsAborted)
|
|
return true;
|
|
return false;
|
|
# endif // !USE_SHELL_API
|
|
#else // !WIN32
|
|
# if USE_SHELL_API
|
|
return std::system(("rm -R " + folder).c_str()) == EXIT_SUCCESS;
|
|
# else // !USE_SHELL_API
|
|
struct dir_deleter {
|
|
dir_deleter() {}
|
|
void operator()(DIR* d) const
|
|
{
|
|
if (d != nullptr)
|
|
{
|
|
int result = closedir(d);
|
|
assert(result == 0);
|
|
}
|
|
}
|
|
};
|
|
using closedir_ptr = std::unique_ptr<DIR, dir_deleter>;
|
|
|
|
std::string filename;
|
|
struct stat statbuf;
|
|
std::size_t folder_len = folder.length();
|
|
struct dirent* p = nullptr;
|
|
|
|
closedir_ptr d(opendir(folder.c_str()));
|
|
bool r = d.get() != nullptr;
|
|
while (r && (p=readdir(d.get())) != nullptr)
|
|
{
|
|
if (strcmp(p->d_name, ".") == 0 || strcmp(p->d_name, "..") == 0)
|
|
continue;
|
|
|
|
// + 2 for path delimiter and nul terminator.
|
|
std::size_t buf_len = folder_len + strlen(p->d_name) + 2;
|
|
filename.resize(buf_len);
|
|
std::size_t path_len = static_cast<std::size_t>(
|
|
snprintf(&filename[0], buf_len, "%s/%s", folder.c_str(), p->d_name));
|
|
assert(path_len == buf_len - 1);
|
|
filename.resize(path_len);
|
|
|
|
if (stat(filename.c_str(), &statbuf) == 0)
|
|
r = S_ISDIR(statbuf.st_mode)
|
|
? remove_folder_and_subfolders(filename)
|
|
: unlink(filename.c_str()) == 0;
|
|
}
|
|
d.reset();
|
|
|
|
if (r)
|
|
r = rmdir(folder.c_str()) == 0;
|
|
|
|
return r;
|
|
# endif // !USE_SHELL_API
|
|
#endif // !WIN32
|
|
}
|
|
|
|
static
|
|
bool
|
|
make_directory(const std::string& folder)
|
|
{
|
|
#ifdef _WIN32
|
|
# if USE_SHELL_API
|
|
// Re-create the folder.
|
|
std::string cmd = "mkdir \"";
|
|
cmd += folder;
|
|
cmd += '\"';
|
|
return std::system(cmd.c_str()) == EXIT_SUCCESS;
|
|
# else // !USE_SHELL_API
|
|
return _mkdir(folder.c_str()) == 0;
|
|
# endif // !USE_SHELL_API
|
|
#else // !WIN32
|
|
# if USE_SHELL_API
|
|
return std::system(("mkdir " + folder).c_str()) == EXIT_SUCCESS;
|
|
# else // !USE_SHELL_API
|
|
return mkdir(folder.c_str(), 0777) == 0;
|
|
# endif // !USE_SHELL_API
|
|
#endif
|
|
}
|
|
|
|
static
|
|
bool
|
|
delete_file(const std::string& file)
|
|
{
|
|
#ifdef _WIN32
|
|
# if USE_SHELL_API
|
|
std::string cmd = "del \"";
|
|
cmd += file;
|
|
cmd += '\"';
|
|
return std::system(cmd.c_str()) == 0;
|
|
# else // !USE_SHELL_API
|
|
return _unlink(file.c_str()) == 0;
|
|
# endif // !USE_SHELL_API
|
|
#else // !WIN32
|
|
# if USE_SHELL_API
|
|
return std::system(("rm " + file).c_str()) == EXIT_SUCCESS;
|
|
# else // !USE_SHELL_API
|
|
return unlink(file.c_str()) == 0;
|
|
# endif // !USE_SHELL_API
|
|
#endif // !WIN32
|
|
}
|
|
|
|
#ifdef TIMEZONE_MAPPING
|
|
|
|
static
|
|
bool
|
|
move_file(const std::string& from, const std::string& to)
|
|
{
|
|
#ifdef _WIN32
|
|
# if USE_SHELL_API
|
|
std::string cmd = "move \"";
|
|
cmd += from;
|
|
cmd += "\" \"";
|
|
cmd += to;
|
|
cmd += '\"';
|
|
return std::system(cmd.c_str()) == EXIT_SUCCESS;
|
|
# else // !USE_SHELL_API
|
|
return !!::MoveFile(from.c_str(), to.c_str());
|
|
# endif // !USE_SHELL_API
|
|
#else // !WIN32
|
|
# if USE_SHELL_API
|
|
return std::system(("mv " + from + " " + to).c_str()) == EXIT_SUCCESS;
|
|
# else
|
|
return rename(from, to) == 0);
|
|
# endif
|
|
#endif // !WIN32
|
|
}
|
|
|
|
#endif // TIMEZONE_MAPPING
|
|
|
|
#ifdef _WIN32
|
|
|
|
// Note folder can and usually does contain spaces.
|
|
static
|
|
std::string
|
|
get_unzip_program()
|
|
{
|
|
std::string path;
|
|
|
|
// 7-Zip appears to note its location in the registry.
|
|
// If that doesn't work, fall through and take a guess, but it will likely be wrong.
|
|
HKEY hKey = nullptr;
|
|
if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\7-Zip", 0, KEY_READ, &hKey) == ERROR_SUCCESS)
|
|
{
|
|
char value_buffer[MAX_PATH + 1]; // fyi 260 at time of writing.
|
|
// in/out parameter. Documentation say that size is a count of bytes not chars.
|
|
DWORD size = sizeof(value_buffer) - sizeof(value_buffer[0]);
|
|
DWORD tzi_type = REG_SZ;
|
|
// Testing shows Path key value is "C:\Program Files\7-Zip\" i.e. always with trailing \.
|
|
bool got_value = (RegQueryValueExA(hKey, "Path", nullptr, &tzi_type,
|
|
reinterpret_cast<LPBYTE>(value_buffer), &size) == ERROR_SUCCESS);
|
|
RegCloseKey(hKey); // Close now incase of throw later.
|
|
if (got_value)
|
|
{
|
|
// Function does not guarantee to null terminate.
|
|
value_buffer[size / sizeof(value_buffer[0])] = '\0';
|
|
path = value_buffer;
|
|
if (!path.empty())
|
|
{
|
|
path += "7z.exe";
|
|
return path;
|
|
}
|
|
}
|
|
}
|
|
path += get_program_folder();
|
|
path += folder_delimiter;
|
|
path += "7-Zip\\7z.exe";
|
|
return path;
|
|
}
|
|
|
|
#if !USE_SHELL_API
|
|
static
|
|
int
|
|
run_program(const std::string& command)
|
|
{
|
|
STARTUPINFO si{};
|
|
si.cb = sizeof(si);
|
|
PROCESS_INFORMATION pi{};
|
|
|
|
// Allegedly CreateProcess overwrites the command line. Ugh.
|
|
std::string mutable_command(command);
|
|
if (CreateProcess(nullptr, &mutable_command[0],
|
|
nullptr, nullptr, FALSE, CREATE_NO_WINDOW, nullptr, nullptr, &si, &pi))
|
|
{
|
|
WaitForSingleObject(pi.hProcess, INFINITE);
|
|
DWORD exit_code;
|
|
bool got_exit_code = !!GetExitCodeProcess(pi.hProcess, &exit_code);
|
|
CloseHandle(pi.hProcess);
|
|
CloseHandle(pi.hThread);
|
|
// Not 100% sure about this still active thing is correct,
|
|
// but I'm going with it because I *think* WaitForSingleObject might
|
|
// return in some cases without INFINITE-ly waiting.
|
|
// But why/wouldn't GetExitCodeProcess return false in that case?
|
|
if (got_exit_code && exit_code != STILL_ACTIVE)
|
|
return static_cast<int>(exit_code);
|
|
}
|
|
return EXIT_FAILURE;
|
|
}
|
|
#endif // !USE_SHELL_API
|
|
|
|
static
|
|
std::string
|
|
get_download_tar_file(const std::string& version)
|
|
{
|
|
auto file = install;
|
|
file += folder_delimiter;
|
|
file += "tzdata";
|
|
file += version;
|
|
file += ".tar";
|
|
return file;
|
|
}
|
|
|
|
static
|
|
bool
|
|
extract_gz_file(const std::string& version, const std::string& gz_file,
|
|
const std::string& dest_folder)
|
|
{
|
|
auto unzip_prog = get_unzip_program();
|
|
bool unzip_result = false;
|
|
// Use the unzip program to extract the tar file from the archive.
|
|
|
|
// Aim to create a string like:
|
|
// "C:\Program Files\7-Zip\7z.exe" x "C:\Users\SomeUser\Downloads\tzdata2016d.tar.gz"
|
|
// -o"C:\Users\SomeUser\Downloads\tzdata"
|
|
std::string cmd;
|
|
cmd = '\"';
|
|
cmd += unzip_prog;
|
|
cmd += "\" x \"";
|
|
cmd += gz_file;
|
|
cmd += "\" -o\"";
|
|
cmd += dest_folder;
|
|
cmd += '\"';
|
|
|
|
#if USE_SHELL_API
|
|
// When using shelling out with std::system() extra quotes are required around the
|
|
// whole command. It's weird but neccessary it seems, see:
|
|
// http://stackoverflow.com/q/27975969/576911
|
|
|
|
cmd = "\"" + cmd + "\"";
|
|
if (std::system(cmd.c_str()) == EXIT_SUCCESS)
|
|
unzip_result = true;
|
|
#else // !USE_SHELL_API
|
|
if (run_program(cmd) == EXIT_SUCCESS)
|
|
unzip_result = true;
|
|
#endif // !USE_SHELL_API
|
|
if (unzip_result)
|
|
delete_file(gz_file);
|
|
|
|
// Use the unzip program extract the data from the tar file that was
|
|
// just extracted from the archive.
|
|
auto tar_file = get_download_tar_file(version);
|
|
cmd = '\"';
|
|
cmd += unzip_prog;
|
|
cmd += "\" x \"";
|
|
cmd += tar_file;
|
|
cmd += "\" -o\"";
|
|
cmd += install;
|
|
cmd += '\"';
|
|
#if USE_SHELL_API
|
|
cmd = "\"" + cmd + "\"";
|
|
if (std::system(cmd.c_str()) == EXIT_SUCCESS)
|
|
unzip_result = true;
|
|
#else // !USE_SHELL_API
|
|
if (run_program(cmd) == EXIT_SUCCESS)
|
|
unzip_result = true;
|
|
#endif // !USE_SHELL_API
|
|
|
|
if (unzip_result)
|
|
delete_file(tar_file);
|
|
|
|
return unzip_result;
|
|
}
|
|
|
|
#else // !_WIN32
|
|
|
|
#if !USE_SHELL_API
|
|
static
|
|
int
|
|
run_program(const char* prog, const char*const args[])
|
|
{
|
|
pid_t pid = fork();
|
|
if (pid == -1) // Child failed to start.
|
|
return EXIT_FAILURE;
|
|
|
|
if (pid != 0)
|
|
{
|
|
// We are in the parent. Child started. Wait for it.
|
|
pid_t ret;
|
|
int status;
|
|
while ((ret = waitpid(pid, &status, 0)) == -1)
|
|
{
|
|
if (errno != EINTR)
|
|
break;
|
|
}
|
|
if (ret != -1)
|
|
{
|
|
if (WIFEXITED(status))
|
|
return WEXITSTATUS(status);
|
|
}
|
|
printf("Child issues!\n");
|
|
|
|
return EXIT_FAILURE; // Not sure what status of child is.
|
|
}
|
|
else // We are in the child process. Start the program the parent wants to run.
|
|
{
|
|
|
|
if (execv(prog, const_cast<char**>(args)) == -1) // Does not return.
|
|
{
|
|
perror("unreachable 0\n");
|
|
_Exit(127);
|
|
}
|
|
printf("unreachable 2\n");
|
|
}
|
|
printf("unreachable 2\n");
|
|
// Unreachable.
|
|
assert(false);
|
|
exit(EXIT_FAILURE);
|
|
return EXIT_FAILURE;
|
|
}
|
|
#endif // !USE_SHELL_API
|
|
|
|
static
|
|
bool
|
|
extract_gz_file(const std::string&, const std::string& gz_file, const std::string&)
|
|
{
|
|
#if USE_SHELL_API
|
|
bool unzipped = std::system(("tar -xzf " + gz_file + " -C " + install).c_str()) == EXIT_SUCCESS;
|
|
#else // !USE_SHELL_API
|
|
const char prog[] = {"/usr/bin/tar"};
|
|
const char*const args[] =
|
|
{
|
|
prog, "-xzf", gz_file.c_str(), "-C", install.c_str(), nullptr
|
|
};
|
|
bool unzipped = (run_program(prog, args) == EXIT_SUCCESS);
|
|
#endif // !USE_SHELL_API
|
|
if (unzipped)
|
|
{
|
|
delete_file(gz_file);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#endif // !_WIN32
|
|
|
|
bool
|
|
remote_install(const std::string& version)
|
|
{
|
|
auto success = false;
|
|
assert(!version.empty());
|
|
|
|
auto gz_file = get_download_gz_file(version);
|
|
if (file_exists(gz_file))
|
|
{
|
|
if (file_exists(install))
|
|
remove_folder_and_subfolders(install);
|
|
if (make_directory(install))
|
|
{
|
|
if (extract_gz_file(version, gz_file, install))
|
|
success = true;
|
|
#ifdef TIMEZONE_MAPPING
|
|
auto mapping_file_source = get_download_mapping_file(version);
|
|
auto mapping_file_dest = install;
|
|
mapping_file_dest += folder_delimiter;
|
|
mapping_file_dest += "windowsZones.xml";
|
|
if (!move_file(mapping_file_source, mapping_file_dest))
|
|
success = false;
|
|
#endif
|
|
}
|
|
}
|
|
return success;
|
|
}
|
|
#endif // HAS_REMOTE_API
|
|
|
|
static
|
|
std::string
|
|
get_version(const std::string& path)
|
|
{
|
|
std::ifstream infile(path + "NEWS");
|
|
std::string version;
|
|
while (infile)
|
|
{
|
|
infile >> version;
|
|
if (version == "Release")
|
|
{
|
|
infile >> version;
|
|
return version;
|
|
}
|
|
}
|
|
throw std::runtime_error("Unable to get Timezone database version from " + path);
|
|
}
|
|
|
|
static
|
|
TZ_DB
|
|
init_tzdb()
|
|
{
|
|
using namespace date;
|
|
const std::string path = install + folder_delimiter;
|
|
std::string line;
|
|
bool continue_zone = false;
|
|
TZ_DB db;
|
|
|
|
#if AUTO_DOWNLOAD
|
|
if (!file_exists(install))
|
|
{
|
|
auto rv = remote_version();
|
|
if (!rv.empty() && remote_download(rv))
|
|
{
|
|
if (!remote_install(rv))
|
|
{
|
|
std::string msg = "Timezone database version \"";
|
|
msg += rv;
|
|
msg += "\" did not install correctly to \"";
|
|
msg += install;
|
|
msg += "\"";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
}
|
|
if (!file_exists(install))
|
|
{
|
|
std::string msg = "Timezone database not found at \"";
|
|
msg += install;
|
|
msg += "\"";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
db.version = get_version(path);
|
|
}
|
|
else
|
|
{
|
|
db.version = get_version(path);
|
|
auto rv = remote_version();
|
|
if (!rv.empty() && db.version != rv)
|
|
{
|
|
if (remote_download(rv))
|
|
{
|
|
remote_install(rv);
|
|
db.version = get_version(path);
|
|
}
|
|
}
|
|
}
|
|
#else // !AUTO_DOWNLOAD
|
|
if (!file_exists(install))
|
|
{
|
|
std::string msg = "Timezone database not found at \"";
|
|
msg += install;
|
|
msg += "\"";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
db.version = get_version(path);
|
|
#endif // !AUTO_DOWNLOAD
|
|
|
|
for (const auto& filename : files)
|
|
{
|
|
std::ifstream infile(path + filename);
|
|
while (infile)
|
|
{
|
|
std::getline(infile, line);
|
|
if (!line.empty() && line[0] != '#')
|
|
{
|
|
std::istringstream in(line);
|
|
std::string word;
|
|
in >> word;
|
|
if (word == "Rule")
|
|
{
|
|
db.rules.push_back(Rule(line));
|
|
continue_zone = false;
|
|
}
|
|
else if (word == "Link")
|
|
{
|
|
db.links.push_back(link(line));
|
|
continue_zone = false;
|
|
}
|
|
else if (word == "Leap")
|
|
{
|
|
db.leaps.push_back(leap(line, detail::undocumented{}));
|
|
continue_zone = false;
|
|
}
|
|
else if (word == "Zone")
|
|
{
|
|
db.zones.push_back(time_zone(line, detail::undocumented{}));
|
|
continue_zone = true;
|
|
}
|
|
else if (line[0] == '\t' && continue_zone)
|
|
{
|
|
db.zones.back().add(line);
|
|
}
|
|
else
|
|
{
|
|
std::cerr << line << '\n';
|
|
}
|
|
}
|
|
}
|
|
}
|
|
std::sort(db.rules.begin(), db.rules.end());
|
|
Rule::split_overlaps(db.rules);
|
|
std::sort(db.zones.begin(), db.zones.end());
|
|
#if !LAZY_INIT
|
|
for (auto& z : db.zones)
|
|
z.adjust_infos(db.rules);
|
|
#endif
|
|
db.zones.shrink_to_fit();
|
|
std::sort(db.links.begin(), db.links.end());
|
|
db.links.shrink_to_fit();
|
|
std::sort(db.leaps.begin(), db.leaps.end());
|
|
db.leaps.shrink_to_fit();
|
|
|
|
#ifdef TIMEZONE_MAPPING
|
|
std::string mapping_file = path + "windowsZones.xml";
|
|
db.mappings = load_timezone_mappings_from_xml_file(mapping_file);
|
|
sort_zone_mappings(db.mappings);
|
|
get_windows_timezone_info(db.native_zones);
|
|
#endif // TIMEZONE_MAPPING
|
|
|
|
return db;
|
|
}
|
|
|
|
static
|
|
TZ_DB&
|
|
access_tzdb()
|
|
{
|
|
static TZ_DB tz_db;
|
|
return tz_db;
|
|
}
|
|
|
|
const TZ_DB&
|
|
reload_tzdb()
|
|
{
|
|
#if AUTO_DOWNLOAD
|
|
auto const& v = access_tzdb().version;
|
|
if (!v.empty() && v == remote_version())
|
|
return access_tzdb();
|
|
#endif
|
|
return access_tzdb() = init_tzdb();
|
|
}
|
|
|
|
const TZ_DB&
|
|
get_tzdb()
|
|
{
|
|
static const TZ_DB& ref = access_tzdb() = init_tzdb();
|
|
return ref;
|
|
}
|
|
|
|
const time_zone*
|
|
locate_zone(const std::string& tz_name)
|
|
{
|
|
const auto& db = get_tzdb();
|
|
auto zi = std::lower_bound(db.zones.begin(), db.zones.end(), tz_name,
|
|
[](const time_zone& z, const std::string& nm)
|
|
{
|
|
return z.name() < nm;
|
|
});
|
|
if (zi == db.zones.end() || zi->name() != tz_name)
|
|
{
|
|
auto li = std::lower_bound(db.links.begin(), db.links.end(), tz_name,
|
|
[](const link& z, const std::string& nm)
|
|
{
|
|
return z.name() < nm;
|
|
});
|
|
if (li != db.links.end() && li->name() == tz_name)
|
|
{
|
|
zi = std::lower_bound(db.zones.begin(), db.zones.end(), li->target(),
|
|
[](const time_zone& z, const std::string& nm)
|
|
{
|
|
return z.name() < nm;
|
|
});
|
|
if (zi != db.zones.end() && zi->name() == li->target())
|
|
return &*zi;
|
|
}
|
|
throw std::runtime_error(tz_name + " not found in timezone database");
|
|
}
|
|
return &*zi;
|
|
}
|
|
|
|
std::ostream&
|
|
operator<<(std::ostream& os, const TZ_DB& db)
|
|
{
|
|
os << "Version: " << db.version << '\n';
|
|
std::string title("--------------------------------------------"
|
|
"--------------------------------------------\n"
|
|
"Name ""Start Y ""End Y "
|
|
"Beginning ""Offset "
|
|
"Designator\n"
|
|
"--------------------------------------------"
|
|
"--------------------------------------------\n");
|
|
int count = 0;
|
|
for (const auto& x : db.rules)
|
|
{
|
|
if (count++ % 50 == 0)
|
|
os << title;
|
|
os << x << '\n';
|
|
}
|
|
os << '\n';
|
|
title = std::string("---------------------------------------------------------"
|
|
"--------------------------------------------------------\n"
|
|
"Name ""Offset "
|
|
"Rule ""Abrev ""Until\n"
|
|
"---------------------------------------------------------"
|
|
"--------------------------------------------------------\n");
|
|
count = 0;
|
|
for (const auto& x : db.zones)
|
|
{
|
|
if (count++ % 10 == 0)
|
|
os << title;
|
|
os << x << '\n';
|
|
}
|
|
os << '\n';
|
|
title = std::string("---------------------------------------------------------"
|
|
"--------------------------------------------------------\n"
|
|
"Alias ""To\n"
|
|
"---------------------------------------------------------"
|
|
"--------------------------------------------------------\n");
|
|
count = 0;
|
|
for (const auto& x : db.links)
|
|
{
|
|
if (count++ % 45 == 0)
|
|
os << title;
|
|
os << x << '\n';
|
|
}
|
|
os << '\n';
|
|
title = std::string("---------------------------------------------------------"
|
|
"--------------------------------------------------------\n"
|
|
"Leap second on\n"
|
|
"---------------------------------------------------------"
|
|
"--------------------------------------------------------\n");
|
|
os << title;
|
|
for (const auto& x : db.leaps)
|
|
os << x << '\n';
|
|
return os;
|
|
}
|
|
|
|
// -----------------------
|
|
|
|
#ifdef _WIN32
|
|
|
|
const time_zone*
|
|
current_zone()
|
|
{
|
|
#ifdef TIMEZONE_MAPPING
|
|
TIME_ZONE_INFORMATION tzi{};
|
|
DWORD tz_result = ::GetTimeZoneInformation(&tzi);
|
|
if (tz_result == TIME_ZONE_ID_INVALID)
|
|
{
|
|
auto error_code = ::GetLastError(); // Store this quick before it gets overwritten.
|
|
throw std::runtime_error("GetTimeZoneInformation failed: "
|
|
+ get_win32_message(error_code));
|
|
}
|
|
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
|
|
std::string standard_name(converter.to_bytes(tzi.StandardName));
|
|
auto tz = find_native_timezone_by_standard_name(standard_name);
|
|
if (!tz)
|
|
{
|
|
std::string msg;
|
|
msg = "current_zone() failed: ";
|
|
msg += standard_name;
|
|
msg += " was not found in the Windows Time Zone registry";
|
|
throw std::runtime_error( msg );
|
|
}
|
|
std::string standard_tzid;
|
|
if (!native_to_standard_timezone_name(tz->timezone_id, standard_tzid))
|
|
{
|
|
std::string msg;
|
|
msg = "current_zone() failed: A mapping from the Windows Time Zone id \"";
|
|
msg += tz->timezone_id;
|
|
msg += "\" was not found in the time zone mapping database.";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
return date::locate_zone(standard_tzid);
|
|
#else // !TIMEZONE_MAPPING
|
|
// Currently Win32 requires iana <--> windows tz name mappings
|
|
// for this function to work.
|
|
// TODO! we should really support TIMEZONE_MAPPINGS=0 on Windows,
|
|
// And in this mode we should read the current iana timezone from a file.
|
|
// This would allow the TZ library do be used by apps that don't care
|
|
// about Windows standard names just iana names.
|
|
// This would allow the xml dependency to be dropped and none of
|
|
// the name mapping functions would be needed.
|
|
throw std::runtime_error("current_zone not implemented.");
|
|
#endif // !TIMEZONE_MAPPING
|
|
}
|
|
|
|
#else // !WIN32
|
|
|
|
const time_zone*
|
|
current_zone()
|
|
{
|
|
// On some OS's a file called /etc/localtime may
|
|
// exist and it may be either a real file
|
|
// containing time zone details or a symlink to such a file.
|
|
// On MacOS and BSD Unix if this file is a symlink it
|
|
// might resolve to a path like this:
|
|
// "/usr/share/zoneinfo/America/Los_Angeles"
|
|
// If it does, we try to determine the current
|
|
// timezone from the remainder of the path by removing the prefix
|
|
// and hoping the rest resolves to valid timezone.
|
|
// It may not always work though. If it doesn't then an
|
|
// exception will be thrown by local_timezone.
|
|
// The path may also take a relative form:
|
|
// "../usr/share/zoneinfo/America/Los_Angeles".
|
|
struct stat sb;
|
|
CONSTDATA auto timezone = "/etc/localtime";
|
|
if (lstat(timezone, &sb) == 0 && S_ISLNK(sb.st_mode) && sb.st_size > 0)
|
|
{
|
|
std::string result(sb.st_size, '\0');
|
|
auto sz = readlink(timezone, &result.front(), result.size());
|
|
if (sz == -1)
|
|
throw std::runtime_error("readlink failure");
|
|
result.resize(sz);
|
|
const char zonepath[] = "/usr/share/zoneinfo/";
|
|
const std::size_t zonepath_len = sizeof(zonepath)/sizeof(zonepath[0])-1;
|
|
const std::size_t pos = result.find(zonepath);
|
|
if (pos != result.npos)
|
|
result.erase(0, zonepath_len+pos);
|
|
return locate_zone(result);
|
|
}
|
|
{
|
|
// On some versions of some linux distro's (e.g. Ubuntu),
|
|
// the current timezone might be in the first line of
|
|
// the /etc/timezone file.
|
|
std::ifstream timezone_file("/etc/timezone");
|
|
if (timezone_file.is_open())
|
|
{
|
|
std::string result;
|
|
std::getline(timezone_file, result);
|
|
if (!result.empty())
|
|
return locate_zone(result);
|
|
}
|
|
// Fall through to try other means.
|
|
}
|
|
{
|
|
// On some versions of some linux distro's (e.g. Red Hat),
|
|
// the current timezone might be in the first line of
|
|
// the /etc/sysconfig/clock file as:
|
|
// ZONE="US/Eastern"
|
|
std::ifstream timezone_file("/etc/sysconfig/clock");
|
|
std::string result;
|
|
while (timezone_file)
|
|
{
|
|
std::getline(timezone_file, result);
|
|
auto p = result.find("ZONE=\"");
|
|
if (p != std::string::npos)
|
|
{
|
|
result.erase(p, p+6);
|
|
result.erase(result.rfind('"'));
|
|
return locate_zone(result);
|
|
}
|
|
}
|
|
// Fall through to try other means.
|
|
}
|
|
throw std::runtime_error("Could not get current timezone");
|
|
}
|
|
|
|
#endif // !WIN32
|
|
|
|
#if defined(TZ_TEST) && defined(TIMEZONE_MAPPING)
|
|
|
|
const time_zone*
|
|
locate_native_zone(const std::string& native_tz_name)
|
|
{
|
|
std::string standard_tz_name;
|
|
if (!native_to_standard_timezone_name(native_tz_name, standard_tz_name))
|
|
{
|
|
std::string msg;
|
|
msg = "locate_native_zone() failed: A mapping from the native/Windows Time Zone id \"";
|
|
msg += native_tz_name;
|
|
msg += "\" was not found in the time zone mapping database.";
|
|
throw std::runtime_error(msg);
|
|
}
|
|
return locate_zone(standard_tz_name);
|
|
}
|
|
|
|
#endif // TZ_TEST && TIMEZONE_MAPPING
|
|
|
|
} // namespace date
|