//******************************************************************************************************

// Convert.cpp - Gbtc

//

// Copyright © 2019, Grid Protection Alliance. All Rights Reserved.

//

// Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See

// the NOTICE file distributed with this work for additional information regarding copyright ownership.

// The GPA licenses this file to you under the MIT License (MIT), the "License"; you may not use this

// file except in compliance with the License. You may obtain a copy of the License at:

//

// http://opensource.org/licenses/MIT

//

// Unless agreed to in writing, the subject software distributed under the License is distributed on an

// "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the

// License for the specific language governing permissions and limitations.

//

// Code Modification History:

// ----------------------------------------------------------------------------------------------------

// 04/06/2012 - Stephen C. Wills

// Generated original version of source code.

//

//******************************************************************************************************

// ReSharper disable CppClangTidyClangDiagnosticExitTimeDestructors

#include "Convert.h"

#include <iomanip>

#include <sstream>

#include <codecvt>

#include <regex>

#include <boost/uuid/uuid_io.hpp>

#include <boost/uuid/string_generator.hpp>

#include <boost/date_time/posix_time/posix_time.hpp>

#include <boost/date_time/gregorian/gregorian.hpp>

#include <boost/date_time/c_local_time_adjustor.hpp>

#include <boost/algorithm/string.hpp>

#include "utf8.h"

using namespace std;

using namespace std::chrono;

using namespace boost::uuids;

using namespace boost::posix_time;

using namespace boost::gregorian;

using namespace boost::asio::ip;

using namespace sttp;

const datetime_t DateTimeEpoch(date(1400, 1, 1), TimeSpan(0, 0, 0));

constexpr int64_t DateTimeTicksPerSecond = TimeSpan::ticks_per_second();

inline int GetRadix(const string& value)

{

return StartsWith(value, "0x") ? 16 : 10;

}

string PreparseTimestamp(const string& timestamp, TimeSpan& utcOffset)

{

// 2018-03-14T19:23:11.665-04:00

vector<string> dateTimeParts = Split(Replace(timestamp, "T", " "), " ", false);

// Failed to understand timestamp format, just return input

if (dateTimeParts.empty() || dateTimeParts.size() > 2)

return timestamp;

string updatedTimestamp{};

string& datePart = dateTimeParts[0];

string part{};

vector<string> dateParts = Split(Replace(datePart, "/", "-", false), "-", false);

if (dateParts.size() != 3)

return timestamp;

string year, month, day;

for (int32_t i = 0; i < 3; i++)

{

part = dateParts[i];

if (part.size() == 1)

part.insert(0, "0");

if (part.size() == 4)

year = part;

else if (month.empty())

month = part;

else

day = part;

}

updatedTimestamp.append(year);

updatedTimestamp.append("-");

updatedTimestamp.append(month);

updatedTimestamp.append("-");

updatedTimestamp.append(day);

if (dateTimeParts.size() == 1)

{

updatedTimestamp.append(" 00:00:00");

return updatedTimestamp;

}

string& timePart = dateTimeParts[1];

// Remove any time zone offset and hold on to it for later

const bool containsMinus = Contains(timePart, "-", false);

vector<string> timeParts = Split(timePart, containsMinus ? "-" : "+", false);

string timeZoneOffset{};

if (timeParts.size() == 2)

{

timePart = timeParts[0];

// Swap timezone sign for conversion to UTC

timeZoneOffset.append(containsMinus ? "+" : "-");

timeZoneOffset.append(Replace(timeParts[1], ":", "", false));

}

timeParts = Split(timePart, ":", false);

if (timeParts.size() == 2)

timeParts.emplace_back("00");

if (timeParts.size() != 3)

return timestamp;

updatedTimestamp.append(" ");

for (int32_t i = 0; i < 3; i++)

{

string fractionalSeconds{};

part = timeParts[i];

if (i == 2 && Contains(part, ".", false))

{

vector<string> secondParts = Split(part, ".", false);

if (secondParts.size() == 2)

{

part = secondParts[0];

fractionalSeconds.append(".");

fractionalSeconds.append(secondParts[1]);

}

}

if (i > 0)

updatedTimestamp.append(":");

if (part.size() == 1)

updatedTimestamp.append("0");

updatedTimestamp.append(part);

if (!fractionalSeconds.empty())

updatedTimestamp.append(fractionalSeconds);

}

if (timeZoneOffset.size() == 5)

{

int32_t hour, minute;

if (TryParseInt32(timeZoneOffset.substr(0, 3), hour) && TryParseInt32(timeZoneOffset.substr(3), minute))

utcOffset = TimeSpan(hour, minute, 0);

}

return updatedTimestamp;

}

void sttp::ToUnixTime(int64_t ticks, time_t& unixSOC, uint16_t& milliseconds)

{

ticks = ticks & Ticks::ValueMask;

// Unix dates are measured as the number of seconds since 1/1/1970

unixSOC = (ticks - Ticks::UnixBaseOffset) / Ticks::PerSecond;

if (unixSOC < 0)

unixSOC = 0;

milliseconds = static_cast<uint16_t>(ticks / 10000 % 1000);

}

datetime_t sttp::FromUnixTime(const time_t unixSOC, const uint16_t milliseconds)

{

return from_time_t(unixSOC) + Milliseconds(milliseconds);

}

datetime_t sttp::FromUnixTimeMicro(const time_t unixSOC, const uint32_t microseconds)

{

return from_time_t(unixSOC) + Microseconds(microseconds);

}

datetime_t sttp::FromTicks(int64_t ticks)

{

ticks = ticks & Ticks::ValueMask;

const datetime_t time = from_time_t((ticks - Ticks::UnixBaseOffset) / Ticks::PerSecond);

const int64_t pticks = ticks % Ticks::PerSecond * DateTimeTicksPerSecond / Ticks::PerSecond;

return time + TimeSpan(0, 0, 0, pticks % DateTimeTicksPerSecond);

}

int64_t sttp::ToTicks(const datetime_t& time)

{

static const int64_t tickInterval = static_cast<int64_t>(pow(10LL, TimeSpan::num_fractional_digits()));

const TimeSpan offset = time - DateTimeEpoch;

return Ticks::PTimeBaseOffset + offset.total_seconds() * Ticks::PerSecond +

offset.fractional_seconds() * Ticks::PerSecond / tickInterval;

}

bool sttp::IsLeapSecond(int64_t ticks)

{

return (ticks & Ticks::LeapSecondFlag) > 0;

}

void sttp::SetLeapSecond(int64_t& ticks)

{

ticks |= Ticks::LeapSecondFlag;

}

bool sttp::IsNegativeLeapSecond(int64_t ticks)

{

return IsLeapSecond(ticks) && (ticks & Ticks::LeapSecondDirection) > 0;

}

void sttp::SetNegativeLeapSecond(int64_t& ticks)

{

ticks |= Ticks::LeapSecondFlag | Ticks::LeapSecondDirection;

}

bool sttp::TimestampIsReasonable(const int64_t value, const float64_t lagTime, const float64_t leadTime, const bool utc)

{

static constexpr float64_t ticksPerSecondF = static_cast<float64_t>(Ticks::PerSecond);

if (lagTime <= 0)

throw runtime_error("lagTime must be greater than zero, but it can be less than one");

if (leadTime <= 0)

throw runtime_error("leadTime must be greater than zero, but it can be less than one");

// Calculate timestamp distance from local system time in seconds

const float64_t distance = (ToTicks(utc ? UtcNow() : Now()) - value) / ticksPerSecondF; // NOLINT

return distance >= -leadTime && distance <= lagTime;

}

bool sttp::TimestampIsReasonable(const datetime_t& value, const float64_t lagTime, const float64_t leadTime, const bool utc)

{

return TimestampIsReasonable(ToTicks(value), lagTime, leadTime, utc);

}

int64_t sttp::RoundToSubsecondDistribution(const int64_t ticks, const int32_t samplesPerSecond)

{

// Baseline timestamp to the top of the second

const int64_t baseTicks = ticks - ticks % Ticks::PerSecond;

// Remove the whole seconds from ticks

const float64_t ticksBeyondSecond = static_cast<float64_t>(ticks - baseTicks);

// Calculate a frame index between 0 and m_framesPerSecond - 1,

// corresponding to ticks rounded to the nearest frame

const int64_t frameIndex = static_cast<int64_t>(round(ticksBeyondSecond / (Ticks::PerSecond / static_cast<float64_t>(samplesPerSecond))));

// Calculate the timestamp of the nearest frame

int64_t destinationTicks = frameIndex * Ticks::PerSecond / samplesPerSecond;

// Recover the seconds that were removed

destinationTicks += baseTicks;

return destinationTicks;

}

uint32_t sttp::TicksToString(char* ptr, const uint32_t maxsize, string format, const int64_t ticks)

{

time_t fromSeconds;

uint16_t milliseconds;

ToUnixTime(ticks, fromSeconds, milliseconds);

stringstream formatStream;

uint32_t formatIndex = 0;

while (formatIndex < format.size())

{

char c = format[formatIndex];

++formatIndex;

if (c != '%')

{

// Not a format specifier

formatStream << c;

continue;

}

// Check for %f and %t format specifiers and handle them

// accordingly. All other specifiers get forwarded to strftime

c = format[formatIndex];

++formatIndex;

switch (c)

{

case 'f':

{

stringstream temp;

temp << setw(3) << setfill('0') << static_cast<int>(milliseconds);

formatStream << temp.str();

break;

}

case 't':

formatStream << ticks;

break;

default:

formatStream << '%' << c;

break;

}

}

struct tm timeinfo{};

#ifdef _WIN32

gmtime_s(&timeinfo, &fromSeconds);

#else

gmtime_r(&fromSeconds, &timeinfo);

#endif

return ConvertUInt32(strftime(ptr, maxsize, formatStream.str().data(), &timeinfo));

}

datetime_t sttp::LocalFromUtc(const datetime_t& timestamp)

{

return boost::date_time::c_local_adjustor<datetime_t>::utc_to_local(timestamp);

}

string sttp::ToString(const Guid& value)

{

return boost::uuids::to_string(value);

}

string sttp::ToString(const datetime_t& value, const char* format)

{

stringstream stream;

const time_facet* facet = new time_facet(format);

auto _ = stream.imbue(locale(stream.getloc(), facet));

stream << value;

return stream.str();

}

string sttp::ToString(const TimeSpan& value)

{

// TODO: Consider improving elapsed time string with hours, minutes, etc.

const float64_t seconds = static_cast<float64_t>(value.total_milliseconds()) / 1000.0;

return ToString(seconds) + " seconds";

}

string sttp::ToString(const decimal_t& value)

{

return value.str();

}

wstring sttp::ToUTF16(const string& value)

{

// wstring_convert is deprecated in C++17.

//wstring_convert<codecvt_utf8_utf16<wchar_t>> converter;

//return converter.from_bytes(value);

wstring wide;

utf8::utf8to32(value.begin(), value.end(), std::back_inserter(wide));

return wide;

}

string sttp::ToUTF8(const wstring& value)

{

// wstring_convert is deprecated in C++17.

//wstring_convert<codecvt_utf8_utf16<wchar_t>> converter;

//return converter.to_bytes(value);

string narrow;

utf8::utf32to8(value.begin(), value.end(), std::back_inserter(narrow));

return narrow;

}

bool sttp::ParseBoolean(const string& value)

{

bool result;

TryParseBoolean(value, result);

return result;

}

bool sttp::TryParseBoolean(const string& value, bool& result, const bool defaultValue)

{

if (value.empty())

{

result = defaultValue;

return false;

}

if (IsEqual(value, "true"))

{

result = true;

return true;

}

if (IsEqual(value, "false"))

{

result = false;

return true;

}

int32_t i32Val;

if (TryParseInt32(value, i32Val))

{

result = i32Val != 0;

return true;

}

const char first = static_cast<char>(toupper(value[0]));

return first == 'T' || first == 'Y';

}

bool sttp::IsInteger(const string& value)

{

int64_t i64Val;

uint64_t ui64Val;

return TryParseInt64(value, i64Val) || TryParseUInt64(value, ui64Val);

}

bool sttp::IsNumeric(const string& value)

{

float64_t f64Val;

return TryParseDouble(value, f64Val);

}

bool sttp::TryParseUInt16(const string& value, uint16_t& result, const uint16_t defaultValue)

{

try

{

const auto conversion = stoul(value, nullptr, GetRadix(value));

if (conversion > UInt16::MaxValue)

{

result = defaultValue;

return false;

}

result = static_cast<uint16_t>(conversion);

return true;

}

catch (...)

{

result = defaultValue;

return false;

}

}

bool sttp::TryParseInt32(const string& value, int32_t& result, const int32_t defaultValue)

{

try

{

result = stoi(value, nullptr, GetRadix(value));

return true;

}

catch (...)

{

result = defaultValue;

return false;

}

}

bool sttp::TryParseUInt32(const string& value, uint32_t& result, const uint32_t defaultValue)

{

try

{

result = stoul(value, nullptr, GetRadix(value));

return true;

}

catch (...)

{

result = defaultValue;

return false;

}

}

bool sttp::TryParseInt64(const string& value, int64_t& result, const int64_t defaultValue)

{

try

{

result = stoll(value, nullptr, GetRadix(value));

return true;

}

catch (...)

{

result = defaultValue;

return false;

}

}

bool sttp::TryParseUInt64(const string& value, uint64_t& result, const uint64_t defaultValue)

{

try

{

result = stoull(value, nullptr, GetRadix(value));

return true;

}

catch (...)

{

result = defaultValue;

return false;

}

}

bool sttp::TryParseDouble(const string& value, float64_t& result, const float64_t defaultValue)

{

try

{

result = stod(value);

return true;

}

catch (...)

{

result = defaultValue;

return false;

}

}

bool sttp::TryParseDecimal(const string& value, decimal_t& result, const decimal_t defaultValue) // NOLINT

{

try

{

result = decimal_t(value);

return true;

}

catch (...)

{

result = defaultValue;

return false;

}

}

string sttp::RegExEncode(const char value)

{

stringstream stream;

stream << std::hex << static_cast<int>(value);

return "\\u" + PadLeft(stream.str(), 4, '0');

}

bool sttp::IsGuid(const string& value)

{

Guid guidVal;

return TryParseGuid(value, guidVal);

}

Guid sttp::ParseGuid(const uint8_t* data, const bool swapEndianness)

{

Guid id;

uint8_t* encodedBytes;

if (swapEndianness)

{

uint8_t swappedBytes[16];

uint8_t copy[8];

for (uint32_t i = 0; i < 16; i++)

{

swappedBytes[i] = data[i];

if (i < 8)

copy[i] = swappedBytes[i];

}

// Convert Microsoft encoding to RFC

swappedBytes[3] = copy[0];

swappedBytes[2] = copy[1];

swappedBytes[1] = copy[2];

swappedBytes[0] = copy[3];

swappedBytes[4] = copy[5];

swappedBytes[5] = copy[4];

swappedBytes[6] = copy[7];

swappedBytes[7] = copy[6];

encodedBytes = swappedBytes;

}

else

{

encodedBytes = const_cast<uint8_t*>(data);

}

for (Guid::iterator iter = id.begin(); iter != id.end(); ++iter, ++encodedBytes)

*iter = *encodedBytes;

return id;

}

Guid sttp::ParseGuid(const char* data)

{

constexpr string_generator generator;

return generator(data);

}

bool sttp::TryParseGuid(const string& value, Guid& result, const Guid defaultValue)

{

try

{

result = ParseGuid(value.c_str());

return true;

}

catch (...)

{

result = defaultValue;

return false;

}

}

void sttp::SwapGuidEndianness(Guid& value)

{

uint8_t* data = value.data;

uint8_t copy[8];

for (uint32_t i = 0; i < 8; i++)

copy[i] = data[i];

// The following uint32 and two uint16 values are little-endian encoded in Microsoft implementations,

// boost follows RFC encoding rules and encodes the bytes as big-endian. For proper Guid interpretation

// by .NET applications the following bytes must be swapped before wire-serialization:

data[3] = copy[0];

data[2] = copy[1];

data[1] = copy[2];

data[0] = copy[3];

data[4] = copy[5];

data[5] = copy[4];

data[6] = copy[7];

data[7] = copy[6];

}

const char* sttp::Coalesce(const char* data, const char* nonEmptyValue)

{

if (data == nullptr)

return nonEmptyValue;

if (data[0] == '\0')

return nonEmptyValue;

return data;

}

// Attempt to parse a timestamp string, e.g.: 2018-03-14T19:23:11.665-04:00

bool sttp::TryParseTimestamp(const char* time, datetime_t& timestamp, const datetime_t& defaultValue, const bool parseAsUTC)

{

static const locale formats[] = {

locale(locale::classic(), new time_input_facet("%Y-%m-%d %H:%M:%S%F")),

locale(locale::classic(), new time_input_facet("%Y%m%dT%H%M%S%F"))

};

TimeSpan utcOffset{};

const string cleanTimestamp = PreparseTimestamp(time, utcOffset);

for (const locale& format : formats)

{

istringstream stream(cleanTimestamp);

auto _ = stream.imbue(format);

stream >> timestamp;

if (static_cast<bool>(stream))

{

if (parseAsUTC)

timestamp += utcOffset;

return true;

}

}

timestamp = defaultValue;

return false;

}

datetime_t sttp::ParseTimestamp(const char* time, const bool parseAsUTC)

{

datetime_t timestamp;

if (TryParseTimestamp(time, timestamp, DateTime::MinValue, parseAsUTC))

return timestamp;

throw runtime_error("Failed to parse timestamp \"" + string(time) + "\"");

}

datetime_t sttp::ParseRelativeTimestamp(const char* time, const datetime_t& defaultValue)

{

static const regex expression(R"(\*\s*([+-]?\d+)\s*(\w+))");

datetime_t timestamp;

if (TryParseTimestamp(time, timestamp, defaultValue, true))

return timestamp;

const datetime_t now = UtcNow();

const string timetag = Trim(time);

smatch match;

if (IsEqual(timetag, "*", false))

return now;

if (regex_search(timetag, match, expression) && match.size() == 3)

{

int32_t offset;

TryParseInt32(match.str(1), offset);

switch (ToLower(Trim(match.str(2)))[0])

{

case 's':

timestamp = DateAdd(now, offset, TimeInterval::Second);

break;

case 'm':

timestamp = DateAdd(now, offset, TimeInterval::Minute);

break;

case 'h':

timestamp = DateAdd(now, offset, TimeInterval::Hour);

break;

case 'd':

timestamp = DateAdd(now, offset, TimeInterval::Day);

break;

default:

timestamp = defaultValue;

break;

}

}

else

{

timestamp = defaultValue;

}

return timestamp;

}

StringMap<string> sttp::ParseKeyValuePairs(const string& value, const char parameterDelimiter, const char keyValueDelimiter, const char startValueDelimiter, const char endValueDelimiter)

{

if (parameterDelimiter == keyValueDelimiter ||

parameterDelimiter == startValueDelimiter ||

parameterDelimiter == endValueDelimiter ||

keyValueDelimiter == startValueDelimiter ||

keyValueDelimiter == endValueDelimiter ||

startValueDelimiter == endValueDelimiter)

throw invalid_argument("All delimiters must be unique");

const string& escapedParameterDelimiter = RegExEncode(parameterDelimiter);

const string& escapedKeyValueDelimiter = RegExEncode(keyValueDelimiter);

const string& escapedStartValueDelimiter = RegExEncode(startValueDelimiter);

const string& escapedEndValueDelimiter = RegExEncode(endValueDelimiter);

const string& escapedBackslashDelimiter = RegExEncode('\\');

const string& parameterDelimiterStr = string(1, parameterDelimiter);

const string& keyValueDelimiterStr = string(1, keyValueDelimiter);

const string& startValueDelimiterStr = string(1, startValueDelimiter);

const string& endValueDelimiterStr = string(1, endValueDelimiter);

const string& backslashDelimiterStr = "\\";

StringMap<string> keyValuePairs;

vector<string> escapedValue;

bool valueEscaped = false;

uint32_t delimiterDepth = 0;

// Escape any parameter or key/value delimiters within tagged value sequences

// For example, the following string:

// "normalKVP=-1; nestedKVP={p1=true; p2=false}")

// would be encoded as:

// "normalKVP=-1; nestedKVP=p1\\u003dtrue\\u003b p2\\u003dfalse")

for (const char character : value)

{

if (character == startValueDelimiter)

{

if (!valueEscaped)

{

valueEscaped = true;

continue; // Don't add tag start delimiter to final value

}

// Handle nested delimiters

delimiterDepth++;

}

if (character == endValueDelimiter)

{

if (valueEscaped)

{

if (delimiterDepth > 0)

{

// Handle nested delimiters

delimiterDepth--;

}

else

{

valueEscaped = false;

continue; // Don't add tag stop delimiter to final value

}

}

else

{

throw runtime_error("Failed to parse key/value pairs: invalid delimiter mismatch. Encountered end value delimiter '" + endValueDelimiterStr + "' before start value delimiter '" + startValueDelimiterStr + "'."); // NOLINT

}

}

if (valueEscaped)

{

// Escape any delimiter characters inside nested key/value pair

if (character == parameterDelimiter)

escapedValue.push_back(escapedParameterDelimiter);

else if (character == keyValueDelimiter)

escapedValue.push_back(escapedKeyValueDelimiter);

else if (character == startValueDelimiter)

escapedValue.push_back(escapedStartValueDelimiter);

else if (character == endValueDelimiter)

escapedValue.push_back(escapedEndValueDelimiter);

else if (character == '\\')

escapedValue.push_back(escapedBackslashDelimiter);

else

escapedValue.emplace_back(1, character);

}

else

{

if (character == '\\')

escapedValue.push_back(escapedBackslashDelimiter);

else

escapedValue.emplace_back(1, character);

}

}

if (delimiterDepth != 0 || valueEscaped)

{

// If value is still escaped, tagged expression was not terminated

if (valueEscaped)

delimiterDepth = 1;

const bool moreStartDelimiters = delimiterDepth > 0;

throw runtime_error(

"Failed to parse key/value pairs: invalid delimiter mismatch. Encountered more " +

(moreStartDelimiters ? "start value delimiters '" + startValueDelimiterStr + "'" : "end value delimiters '" + endValueDelimiterStr + "'") + " than " +

(moreStartDelimiters ? "end value delimiters '" + endValueDelimiterStr + "'" : "start value delimiters '" + startValueDelimiterStr + "'") + ".");

}

// Parse key/value pairs from escaped value

const vector<string> pairs = Split(boost::algorithm::join(escapedValue, ""), parameterDelimiterStr, false);

for (const string& pair : pairs)

{

// Separate key from value

vector<string> elements = Split(pair, keyValueDelimiterStr, false);

if (elements.size() == 2)

{

// Get key

const string key = Trim(elements[0]);

// Get unescaped value

const string unescapedValue = Replace(Replace(Replace(Replace(Replace(Trim(elements[1]),

escapedParameterDelimiter, parameterDelimiterStr, false),

escapedKeyValueDelimiter, keyValueDelimiterStr, false),

escapedStartValueDelimiter, startValueDelimiterStr, false),

escapedEndValueDelimiter, endValueDelimiterStr, false),

escapedBackslashDelimiter, backslashDelimiterStr, false);

// Add or replace key elements with unescaped value

keyValuePairs[key] = unescapedValue;

}

}

return keyValuePairs;

}

std::string sttp::ResolveDNSName(IOContext& service, const TcpEndPoint& source)

{

string hostName;

return ResolveDNSName(service, source, hostName);

}

string sttp::ResolveDNSName(IOContext& service, const TcpEndPoint& source, string& hostName)

{

const IPAddress address = source.address();

const string port = ToString(source.port());

string connectionID;

if (source.protocol() == tcp::v6())

connectionID = "[" + address.to_string() + "]:" + port;

else

connectionID = address.to_string() + ":" + port;

hostName.clear();

try

{

DnsResolver resolver(service);

const DnsResolver::query dnsQuery(address.to_string(), port);

DnsResolver::iterator iterator = resolver.resolve(dnsQuery);

const DnsResolver::iterator end;

while (iterator != end)

{

const auto& endPoint = *iterator++;

if (!endPoint.host_name().empty())

{

hostName = endPoint.host_name();

connectionID = hostName + " (" + connectionID + ")"; // NOLINT

break;

}

}

}

catch (...)

{ //-V565

// DNS lookup failure is not catastrophic

}

if (hostName.empty())

hostName = address.to_string();

return connectionID;

}