// vim:set sw=2 ts=2 sts et:
//
// Copyright 2024 Rutger Broekhoff. Licensed under the EUPL.
#include <tmi8/kv1_parser.hpp>
using rune = uint32_t;
static size_t decodeUtf8Cp(std::string_view s, rune *dest = nullptr) {
rune res = 0xFFFD;
size_t length = 1;
if (s.size() == 0)
return 0;
const uint8_t *b = reinterpret_cast<const uint8_t *>(s.data());
if (!(b[0] & 0x80))
res = static_cast<rune>(b[0]);
else if ((b[0] & 0xE0) == 0xC0) {
length = 2;
if (s.size() >= 2 && (b[1] & 0xC0) == 0x80) {
res = static_cast<rune>(b[0] & ~0xC0) << 6;
res |= static_cast<rune>(b[1] & ~0x80);
}
} else if ((b[0] & 0xF0) == 0xE0) {
length = 3;
if (s.size() >= 3 && (b[1] & 0xC0) == 0x80 && (b[2] & 0xC0) == 0x80) {
res = static_cast<rune>(b[0] & ~0xE0) << 12;
res |= static_cast<rune>(b[1] & ~0x80) << 6;
res |= static_cast<rune>(b[2] & ~0x80);
}
} else if (b[0] == 0xF0) {
length = 4;
if (s.size() >= 4 && (b[1] & 0xC0) == 0x80 && (b[2] & 0xC0) == 0x80 && (b[3] & 0xC0) == 0x80) {
res = static_cast<rune>(b[0] & ~0xF0) << 18;
res |= static_cast<rune>(b[1] & ~0x80) << 12;
res |= static_cast<rune>(b[2] & ~0x80) << 6;
res |= static_cast<rune>(b[3] & ~0x80);
}
}
if (dest)
*dest = res;
return length;
}
// Counts the number of codepoints in a valid UTF-8 string. Returns SIZE_MAX if
// the string contains invalid UTF-8 codepoints.
static size_t stringViewLengthUtf8(std::string_view sv) {
size_t codepoints = 0;
while (sv.size() > 0) {
size_t codepoint_size = decodeUtf8Cp(sv);
if (codepoint_size == 0) return SIZE_MAX;
codepoints++;
sv = sv.substr(codepoint_size);
}
return codepoints;
}
Kv1Parser::Kv1Parser(std::vector<Kv1Token> tokens, Kv1Records &parse_into)
: tokens(std::move(tokens)),
records(parse_into)
{}
bool Kv1Parser::atEnd() const {
return pos >= tokens.size();
}
void Kv1Parser::eatRowEnds() {
while (!atEnd() && tokens[pos].type == KV1_TOKEN_ROW_END) pos++;
}
const Kv1Token *Kv1Parser::cur() const {
if (atEnd()) return nullptr;
return &tokens[pos];
}
const std::string *Kv1Parser::eatCell(std::string_view parsing_what) {
const Kv1Token *tok = cur();
if (!tok) {
record_errors.push_back(std::format("Expected cell but got end of file when parsing {}", parsing_what));
return nullptr;
}
if (tok->type == KV1_TOKEN_ROW_END) {
record_errors.push_back(std::format("Expected cell but got end of row when parsing {}", parsing_what));
return nullptr;
}
pos++;
return &tok->data;
}
void Kv1Parser::requireString(std::string_view field, bool mandatory, size_t max_length, std::string_view value) {
if (value.empty() && mandatory) {
record_errors.push_back(std::format("{} has length zero but is required", field));
return;
}
size_t codepoints = stringViewLengthUtf8(value);
if (codepoints == SIZE_MAX) {
global_errors.push_back(std::format("{} contains invalid UTF-8 code points", field));
return;
}
if (codepoints > max_length) {
record_errors.push_back(std::format("{} has length ({}) that is greater than maximum length ({})",
field, value.size(), max_length));
}
}
static inline std::optional<bool> parseBoolean(std::string_view src) {
if (src == "1") return true;
if (src == "0") return false;
if (src == "true") return true;
if (src == "false") return false;
return std::nullopt;
}
std::optional<bool> Kv1Parser::requireBoolean(std::string_view field, bool mandatory, std::string_view value) {
if (value.empty()) {
if (mandatory)
record_errors.push_back(std::format("{} is required, but has no value", field));
return std::nullopt;
}
auto parsed = parseBoolean(value);
if (!parsed.has_value())
record_errors.push_back(std::format("{} should have value \"1\", \"0\", \"true\" or \"false\"", field));
return parsed;
}
static inline size_t countDigits(long x) {
size_t digits = 0;
while (x != 0) { digits++; x /= 10; }
return digits;
}
std::optional<double> Kv1Parser::requireNumber(std::string_view field, bool mandatory, size_t max_digits, std::string_view value) {
if (value.empty()) {
if (mandatory)
record_errors.push_back(std::format("{} has no value but is required", field));
return std::nullopt;
}
double parsed;
auto [ptr, ec] = std::from_chars(value.data(), value.data() + value.size(), parsed, std::chars_format::fixed);
if (ec != std::errc()) {
record_errors.push_back(std::format("{} has a bad value that cannot be parsed as a number", field));
return std::nullopt;
}
if (ptr != value.data() + value.size()) {
record_errors.push_back(std::format("{} contains characters that were not parsed as a number", field));
return std::nullopt;
}
size_t digits = countDigits(static_cast<long>(parsed));
if (digits > max_digits) {
record_errors.push_back(std::format("{} contains more digits (in the integral part) ({}) than allowed ({})",
field, digits, max_digits));
return std::nullopt;
}
return parsed;
}
static inline bool isHexDigit(char c) {
return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'F');
}
static inline uint8_t fromHex(char c) {
if (c >= '0' && c <= '9') return static_cast<uint8_t>(c - '0');
else if (c >= 'A' && c <= 'F') return static_cast<uint8_t>(c - 'A' + 10);
return 0;
}
static std::optional<RgbColor> parseRgbColor(std::string_view src) {
bool valid = src.size() == 6
&& isHexDigit(src[0]) && isHexDigit(src[1])
&& isHexDigit(src[2]) && isHexDigit(src[3])
&& isHexDigit(src[4]) && isHexDigit(src[5]);
if (!valid) return std::nullopt;
uint8_t r = static_cast<uint8_t>(fromHex(src[0]) << 4) + fromHex(src[1]);
uint8_t g = static_cast<uint8_t>(fromHex(src[2]) << 4) + fromHex(src[3]);
uint8_t b = static_cast<uint8_t>(fromHex(src[4]) << 4) + fromHex(src[5]);
return RgbColor{ r, g, b };
}
std::optional<RgbColor> Kv1Parser::requireRgbColor(std::string_view field, bool mandatory, std::string_view value) {
if (value.empty()) {
if (mandatory)
record_errors.push_back(std::format("{} is required, but has no value", field));
return std::nullopt;
}
auto parsed = parseRgbColor(value);
if (!parsed.has_value())
record_errors.push_back(std::format("{} should be an RGB color, i.e. a sequence of six hexadecimally represented nibbles", field));
return parsed;
}
std::optional<double> Kv1Parser::requireRdCoord(std::string_view field, bool mandatory, size_t min_digits, std::string_view value) {
if (value.empty()) {
if (mandatory)
record_errors.push_back(std::format("{} is required, but has no value", field));
return std::nullopt;
}
if (value.size() > 15) {
record_errors.push_back(std::format("{} may not have more than 15 characters", field));
return std::nullopt;
}
double parsed;
auto [ptr, ec] = std::from_chars(value.data(), value.data() + value.size(), parsed, std::chars_format::fixed);
if (ec != std::errc()) {
record_errors.push_back(std::format("{} has a bad value that cannot be parsed as a number", field));
return std::nullopt;
}
if (ptr != value.data() + value.size()) {
record_errors.push_back(std::format("{} contains characters that were not parsed as a number", field));
return std::nullopt;
}
size_t digits = countDigits(static_cast<long>(parsed));
if (digits < min_digits) {
record_errors.push_back(std::format("{} contains less digits (in the integral part) ({}) than required ({}) [value: {}]",
field, digits, min_digits, value));
return std::nullopt;
}
return parsed;
}
std::string Kv1Parser::eatString(std::string_view field, bool mandatory, size_t max_length) {
auto value = eatCell(field);
if (!record_errors.empty()) return {};
requireString(field, mandatory, max_length, *value);
return std::move(*value);
}
std::optional<bool> Kv1Parser::eatBoolean(std::string_view field, bool mandatory) {
auto value = eatCell(field);
if (!record_errors.empty()) return {};
return requireBoolean(field, mandatory, *value);
}
std::optional<double> Kv1Parser::eatNumber(std::string_view field, bool mandatory, size_t max_digits) {
auto value = eatCell(field);
if (!record_errors.empty()) return {};
return requireNumber(field, mandatory, max_digits, *value);
}
std::optional<RgbColor> Kv1Parser::eatRgbColor(std::string_view field, bool mandatory) {
auto value = eatCell(field);
if (!record_errors.empty()) return {};
return requireRgbColor(field, mandatory, *value);
}
std::optional<double> Kv1Parser::eatRdCoord(std::string_view field, bool mandatory, size_t min_digits) {
auto value = eatCell(field);
if (!record_errors.empty()) return {};
return requireRdCoord(field, mandatory, min_digits, *value);
}
std::string Kv1Parser::parseHeader() {
auto record_type = eatString("<header>.Recordtype", true, 10);
auto version_number = eatString("<header>.VersionNumber", true, 2);
auto implicit_explicit = eatString("<header>.Implicit/Explicit", true, 1);
if (!record_errors.empty()) return {};
if (version_number != "1") {
record_errors.push_back("<header>.VersionNumber should be 1");
return "";
}
if (implicit_explicit != "I") {
record_errors.push_back("<header>.Implicit/Explicit should be 'I'");
return "";
}
return record_type;
}
void Kv1Parser::eatRestOfRow() {
while (!atEnd() && cur()->type != KV1_TOKEN_ROW_END) pos++;
}
void Kv1Parser::parse() {
while (!atEnd()) {
eatRowEnds();
if (atEnd()) return;
std::string record_type = parseHeader();
if (!record_errors.empty()) break;
if (!type_parsers.contains(record_type)) {
warns.push_back(std::format("Recordtype ({}) is bad or names a record type that this program cannot process",
record_type));
eatRestOfRow();
continue;
}
ParseFunc parseType = Kv1Parser::type_parsers.at(record_type);
(this->*parseType)();
if (cur() && cur()->type != KV1_TOKEN_ROW_END) {
record_errors.push_back(std::format("Parser function for Recordtype ({}) did not eat all record fields",
record_type));
eatRestOfRow();
}
if (!record_errors.empty()) {
global_errors.insert(global_errors.end(), record_errors.begin(), record_errors.end());
record_errors.clear();
}
}
}
void Kv1Parser::parseOrganizationalUnit() {
auto data_owner_code = eatString("ORUN.DataOwnerCode", true, 10);
auto organizational_unit_code = eatString("ORUN.OrganizationalUnitCode", true, 10);
auto name = eatString("ORUN.Name", true, 50);
auto organizational_unit_type = eatString("ORUN.OrganizationalUnitType", true, 10);
auto description = eatString("ORUN.Description", false, 255);
if (!record_errors.empty()) return;
records.organizational_units.emplace_back(
Kv1OrganizationalUnit::Key(
data_owner_code,
organizational_unit_code),
name,
organizational_unit_type,
description);
}
static inline bool isDigit(char c) {
return c >= '0' && c <= '9';
}
// Parse a string of the format YYYY-MM-DD.
static std::optional<std::chrono::year_month_day> parseYyyymmdd(std::string_view src) {
bool valid = src.size() == 10
&& isDigit(src[0]) && isDigit(src[1])
&& isDigit(src[2]) && isDigit(src[3]) && src[4] == '-'
&& isDigit(src[5]) && isDigit(src[6]) && src[7] == '-'
&& isDigit(src[8]) && isDigit(src[9]);
if (!valid) return std::nullopt;
int year = (src[0] - '0') * 1000 + (src[1] - '0') * 100 + (src[2] - '0') * 10 + src[3] - '0';
int month = (src[5] - '0') * 10 + src[6] - '0';
int day = (src[8] - '0') * 10 + src[9] - '0';
return std::chrono::year(year) / std::chrono::month(month) / std::chrono::day(day);
}
// Parse a string of the format HH:MM:SS.
static std::optional<std::chrono::hh_mm_ss<std::chrono::seconds>> parseHhmmss(std::string_view src) {
bool valid = src.size() == 8
&& isDigit(src[0]) && isDigit(src[1]) && src[2] == ':'
&& isDigit(src[3]) && isDigit(src[4]) && src[5] == ':'
&& isDigit(src[6]) && isDigit(src[7]);
if (!valid) return std::nullopt;
int hh = (src[0] - '0') * 10 + src[1] - '0';
int mm = (src[3] - '0') * 10 + src[4] - '0';
int ss = (src[6] - '0') * 10 + src[7] - '0';
// The check for the hour not being greater than 32 comes from the fact the
// specification explicitly allows hours greater than 23, noting that the
// period 24:00-32:00 is equivalent to 00:00-08:00 in the next day, for
// exploitation of two days.
if (hh > 32 || mm > 59 || ss > 59) return std::nullopt;
return std::chrono::hh_mm_ss(std::chrono::hours(hh) + std::chrono::minutes(mm) + std::chrono::seconds(ss));
}
static std::optional<std::chrono::sys_seconds> parseDateTime(std::string_view src, const std::chrono::time_zone *amsterdam, std::string_view *error = nullptr) {
#define ERROR(err) do { if (error) *error = err; return std::nullopt; } while (0)
if (src.size() > 23) ERROR("timestamp string is too big");
if (src.size() < 17) ERROR("timestamp string is too small");
bool valid_year = isDigit(src[0]) && isDigit(src[1]) && isDigit(src[2]) && isDigit(src[3]);
if (!valid_year) ERROR("year has bad format");
size_t month_off = src[4] == '-' ? 5 : 4;
size_t day_off = src[month_off + 2] == '-' ? month_off + 3 : month_off + 2;
size_t time_off = day_off + 2;
if (src[time_off] != 'T' && src[time_off] != ' ')
ERROR("missing date/time separator");
size_t tzd_off = time_off + 9;
// For clarity, TZD stands for Time Zone Designator. It often takes the form
// of Z (Zulu, UTC+00:00) or as an offset from UTC in hours and minutes,
// formatted as ±HH:MM (e.g. +01:00, -12:00).
if (time_off + 8 >= src.size()) ERROR("bad format, not enough space for hh:mm:ss");
int year = (src[0] - '0') * 1000 + (src[1] - '0') * 100 + (src[2] - '0') * 10 + src[3] - '0';
int month = (src[month_off] - '0') * 10 + src[month_off + 1] - '0';
int day = (src[day_off] - '0') * 10 + src[day_off + 1] - '0';
int hour = (src[time_off + 1] - '0') * 10 + src[time_off + 2] - '0';
int minute = (src[time_off + 4] - '0') * 10 + src[time_off + 5] - '0';
int second = (src[time_off + 7] - '0') * 10 + src[time_off + 8] - '0';
auto date = std::chrono::year(year) / std::chrono::month(month) / std::chrono::day(day);
auto time = std::chrono::hours(hour) + std::chrono::minutes(minute) + std::chrono::seconds(second);
std::chrono::sys_seconds unix_start_of_day;
if (tzd_off < src.size()) {
unix_start_of_day = std::chrono::sys_days(date);
} else {
auto local_days = std::chrono::local_days(date);
std::chrono::zoned_seconds zoned_start_of_day = std::chrono::zoned_time(amsterdam, local_days);
unix_start_of_day = std::chrono::sys_seconds(zoned_start_of_day);
}
std::chrono::minutes offset(0);
if (tzd_off + 1 == src.size() && src[tzd_off] != 'Z') {
ERROR("bad TZD (missing Zulu indicator)");
} else if (tzd_off + 6 == src.size()) {
bool valid_tzd = (src[tzd_off] == '+' || src[tzd_off] == '-')
&& isDigit(src[tzd_off + 1]) && isDigit(src[tzd_off + 2]) && src[tzd_off + 3] == ':'
&& isDigit(src[tzd_off + 4]) && isDigit(src[tzd_off + 5]);
if (!valid_tzd) ERROR("bad offset TZD format (expected +|-hh:mm)");
int sign = src[tzd_off] == '-' ? -1 : 1;
int tzd_hh = (src[tzd_off + 1] - '0') * 10 + src[tzd_off + 2] - '0';
int tzd_mm = (src[tzd_off + 3] - '0') * 10 + src[tzd_off + 4] - '0';
offset = sign * std::chrono::minutes(tzd_hh * 60 + tzd_mm);
} else if (tzd_off < src.size()) {
// There is a TZD but we literally have no clue how to parse it :/
ERROR("cannot parse TZD of unexpected length");
}
return unix_start_of_day + time - offset;
#undef ERROR
}
void Kv1Parser::parseHigherOrganizationalUnit() {
auto data_owner_code = eatString("ORUNORUN.DataOwnerCode", true, 10);
auto organizational_unit_code_parent = eatString("ORUNORUN.OrganizationalUnitCodeParent", true, 10);
auto organizational_unit_code_child = eatString("ORUNORUN.OrganizationalUnitCodeChild", true, 10);
auto valid_from_raw = eatString("ORUNORUN.ValidFrom", true, 10);
if (!record_errors.empty()) return;
auto valid_from = parseYyyymmdd(valid_from_raw);
if (!valid_from) {
record_errors.push_back("ORUNORUN.ValidFrom has invalid format, should be YYYY-MM-DD");
return;
}
records.higher_organizational_units.emplace_back(
Kv1HigherOrganizationalUnit::Key(
data_owner_code,
organizational_unit_code_parent,
organizational_unit_code_child,
*valid_from));
}
void Kv1Parser::parseUserStopPoint() {
auto data_owner_code = eatString ("USRSTOP.DataOwnerCode", true, 10);
auto user_stop_code = eatString ("USRSTOP.UserStopCode", true, 10);
auto timing_point_code = eatString ("USRSTOP.TimingPointCode", false, 10);
auto get_in = eatBoolean("USRSTOP.GetIn", true );
auto get_out = eatBoolean("USRSTOP.GetOut", true );
eatCell ("USRSTOP.<deprecated field #1>" );
auto name = eatString ("USRSTOP.Name", true, 50);
auto town = eatString ("USRSTOP.Town", true, 50);
auto user_stop_area_code = eatString ("USRSTOP.UserStopAreaCode", false, 10);
auto stop_side_code = eatString ("USRSTOP.StopSideCode", true, 10);
eatCell ("USRSTOP.<deprecated field #2>" );
eatCell ("USRSTOP.<deprecated field #3>" );
auto minimal_stop_time = eatNumber ("USRSTOP.MinimalStopTime", true, 5);
auto stop_side_length = eatNumber ("USRSTOP.StopSideLength", false, 3);
auto description = eatString ("USRSTOP.Description", false, 255);
auto user_stop_type = eatString ("USRSTOP.UserStopType", true, 10);
auto quay_code = eatString ("USRSTOP.QuayCode", false, 30);
if (!record_errors.empty()) return;
records.user_stop_points.emplace_back(
Kv1UserStopPoint::Key(
data_owner_code,
user_stop_code),
timing_point_code,
*get_in,
*get_out,
name,
town,
user_stop_area_code,
stop_side_code,
*minimal_stop_time,
stop_side_length,
description,
user_stop_type,
quay_code);
}
void Kv1Parser::parseUserStopArea() {
auto data_owner_code = eatString("USRSTAR.DataOwnerCode", true, 10);
auto user_stop_area_code = eatString("USRSTAR.UserStopAreaCode", true, 10);
auto name = eatString("USRSTAR.Name", true, 50);
auto town = eatString("USRSTAR.Town", true, 50);
eatCell ("USRSTAR.<deprecated field #1>" );
eatCell ("USRSTAR.<deprecated field #2>" );
auto description = eatString("USRSTAR.Description", false, 255);
if (!record_errors.empty()) return;
records.user_stop_areas.emplace_back(
Kv1UserStopArea::Key(
data_owner_code,
user_stop_area_code),
name,
town,
description);
}
void Kv1Parser::parseTimingLink() {
auto data_owner_code = eatString("TILI.DataOwnerCode", true, 10);
auto user_stop_code_begin = eatString("TILI.UserStopCodeBegin", true, 10);
auto user_stop_code_end = eatString("TILI.UserStopCodeEnd", true, 10);
auto minimal_drive_time = eatNumber("TILI.MinimalDriveTime", false, 5);
auto description = eatString("TILI.Description", false, 255);
if (!record_errors.empty()) return;
records.timing_links.emplace_back(
Kv1TimingLink::Key(
data_owner_code,
user_stop_code_begin,
user_stop_code_end),
minimal_drive_time,
description);
}
void Kv1Parser::parseLink() {
auto data_owner_code = eatString("LINK.DataOwnerCode", true, 10);
auto user_stop_code_begin = eatString("LINK.UserStopCodeBegin", true, 10);
auto user_stop_code_end = eatString("LINK.UserStopCodeEnd", true, 10);
eatCell("LINK.<deprecated field #1>" );
auto distance = eatNumber("LINK.Distance", true, 6);
auto description = eatString("LINK.Description", false, 255);
auto transport_type = eatString("LINK.TransportType", true, 5);
if (!record_errors.empty()) return;
records.links.emplace_back(
Kv1Link::Key(
data_owner_code,
user_stop_code_begin,
user_stop_code_end,
transport_type),
*distance,
description);
}
void Kv1Parser::parseLine() {
auto data_owner_code = eatString ("LINE.DataOwnerCode", true, 10);
auto line_planning_number = eatString ("LINE.LinePlanningNumber", true, 10);
auto line_public_number = eatString ("LINE.LinePublicNumber", true, 4);
auto line_name = eatString ("LINE.LineName", true, 50);
auto line_ve_tag_number = eatNumber ("LINE.LineVeTagNumber", true, 3);
auto description = eatString ("LINE.Description", false, 255);
auto transport_type = eatString ("LINE.TransportType", true, 5);
auto line_icon = eatNumber ("LINE.LineIcon", false, 4);
auto line_color = eatRgbColor("LINE.LineColor", false );
auto line_text_color = eatRgbColor("LINE.LineTextColor", false );
if (!record_errors.empty()) return;
// NOTE: This check, although it should be performed to comply with the
// specification, is not actually honored by transit operators (such as
// Connexxion) :/ That's enough reason to keep it disabled here for now.
// if (*line_ve_tag_number < 0 || *line_ve_tag_number > 399) {
// record_errors.push_back(std::format("LINE.LineVeTagNumber is out of range [0-399] with value {}", *line_ve_tag_number));
// return;
// }
if (*line_ve_tag_number != static_cast<short>(*line_ve_tag_number))
record_errors.push_back("LINE.LineVeTagNumber should be an integer");
if (line_icon && *line_icon != static_cast<short>(*line_icon))
record_errors.push_back("LINE.LineIcon should be an integer");
if (!record_errors.empty()) return;
records.lines.emplace_back(
Kv1Line::Key(
data_owner_code,
line_planning_number),
line_public_number,
line_name,
static_cast<short>(*line_ve_tag_number),
description,
transport_type,
static_cast<std::optional<short>>(line_icon),
line_color,
line_text_color);
}
void Kv1Parser::parseDestination() {
auto data_owner_code = eatString ("DEST.DataOwnerCode", true, 10);
auto dest_code = eatString ("DEST.DestCode", true, 10);
auto dest_name_full = eatString ("DEST.DestNameFull", true, 50);
auto dest_name_main = eatString ("DEST.DestNameMain", true, 24);
auto dest_name_detail = eatString ("DEST.DestNameDetail", false, 24);
auto relevant_dest_name_detail = eatBoolean ("DEST.RelevantDestNameDetail", true );
auto dest_name_main_21 = eatString ("DEST.DestNameMain21", true, 21);
auto dest_name_detail_21 = eatString ("DEST.DestNameDetail21", false, 21);
auto dest_name_main_19 = eatString ("DEST.DestNameMain19", true, 19);
auto dest_name_detail_19 = eatString ("DEST.DestNameDetail19", false, 19);
auto dest_name_main_16 = eatString ("DEST.DestNameMain16", true, 16);
auto dest_name_detail_16 = eatString ("DEST.DestNameDetail16", false, 16);
auto dest_icon = eatNumber ("DEST.DestIcon", false, 4);
auto dest_color = eatRgbColor("DEST.DestColor", false );
// NOTE: Deviating from the offical KV1 specification here. It specifies that
// the maximum length for this field should be 30, but then proceeds to
// specify that it should contain a RGB value comprising of three
// hexadecimally encoded octets, i.e. six characters. We assume that the
// latter is correct and the intended interpretation.
auto dest_text_color = eatRgbColor("DEST.DestTextColor", false );
if (!record_errors.empty()) return;
if (dest_icon && *dest_icon != static_cast<short>(*dest_icon)) {
record_errors.push_back("DEST.DestIcon should be an integer");
return;
}
records.destinations.emplace_back(
Kv1Destination::Key(
data_owner_code,
dest_code),
dest_name_full,
dest_name_main,
dest_name_detail,
*relevant_dest_name_detail,
dest_name_main_21,
dest_name_detail_21,
dest_name_main_19,
dest_name_detail_19,
dest_name_main_16,
dest_name_detail_16,
dest_icon,
dest_color,
dest_text_color);
}
void Kv1Parser::parseJourneyPattern() {
auto data_owner_code = eatString("JOPA.DataOwnerCode", true, 10);
auto line_planning_number = eatString("JOPA.LinePlanningNumber", true, 10);
auto journey_pattern_code = eatString("JOPA.JourneyPatternCode", true, 10);
auto journey_pattern_type = eatString("JOPA.JourneyPatternType", true, 10);
auto direction = eatString("JOPA.Direction", true, 1);
auto description = eatString("JOPA.Description", false, 255);
if (!record_errors.empty()) return;
if (direction != "1" && direction != "2" && direction != "A" && direction != "B") {
record_errors.push_back("JOPA.Direction should be in [1, 2, A, B]");
return;
}
records.journey_patterns.emplace_back(
Kv1JourneyPattern::Key(
data_owner_code,
line_planning_number,
journey_pattern_code),
journey_pattern_type,
direction[0],
description);
}
void Kv1Parser::parseConcessionFinancerRelation() {
auto data_owner_code = eatString("CONFINREL.DataOwnerCode", true, 10);
auto con_fin_rel_code = eatString("CONFINREL.ConFinRelCode", true, 10);
auto concession_area_code = eatString("CONFINREL.ConcessionAreaCode", true, 10);
auto financer_code = eatString("CONFINREL.FinancerCode", false, 10);
if (!record_errors.empty()) return;
records.concession_financer_relations.emplace_back(
Kv1ConcessionFinancerRelation::Key(
data_owner_code,
con_fin_rel_code),
concession_area_code,
financer_code);
}
void Kv1Parser::parseConcessionArea() {
auto data_owner_code = eatString("CONAREA.DataOwnerCode", true, 10);
auto concession_area_code = eatString("CONAREA.ConcessionAreaCode", true, 10);
auto description = eatString("CONAREA.Description", true, 255);
if (!record_errors.empty()) return;
records.concession_areas.emplace_back(
Kv1ConcessionArea::Key(
data_owner_code,
concession_area_code),
description);
}
void Kv1Parser::parseFinancer() {
auto data_owner_code = eatString("FINANCER.DataOwnerCode", true, 10);
auto financer_code = eatString("FINANCER.FinancerCode", true, 10);
auto description = eatString("FINANCER.Description", true, 255);
if (!record_errors.empty()) return;
records.financers.emplace_back(
Kv1Financer::Key(
data_owner_code,
financer_code),
description);
}
void Kv1Parser::parseJourneyPatternTimingLink() {
auto data_owner_code = eatString ("JOPATILI.DataOwnerCode", true, 10);
auto line_planning_number = eatString ("JOPATILI.LinePlanningNumber", true, 10);
auto journey_pattern_code = eatString ("JOPATILI.JourneyPatternCode", true, 10);
auto timing_link_order = eatNumber ("JOPATILI.TimingLinkOrder", true, 3);
auto user_stop_code_begin = eatString ("JOPATILI.UserStopCodeBegin", true, 10);
auto user_stop_code_end = eatString ("JOPATILI.UserStopCodeEnd", true, 10);
auto con_fin_rel_code = eatString ("JOPATILI.ConFinRelCode", true, 10);
auto dest_code = eatString ("JOPATILI.DestCode", true, 10);
eatCell ("JOPATILI.<deprecated field #1>" );
auto is_timing_stop = eatBoolean ("JOPATILI.IsTimingStop", true );
auto display_public_line = eatString ("JOPATILI.DisplayPublicLine", false, 4);
auto product_formula_type = eatNumber ("JOPATILI.ProductFormulaType", false, 4);
auto get_in = eatBoolean ("JOPATILI.GetIn", true );
auto get_out = eatBoolean ("JOPATILI.GetOut", true );
auto show_flexible_trip = eatString ("JOPATILI.ShowFlexibleTrip", false, 8);
auto line_dest_icon = eatNumber ("JOPATILI.LineDestIcon", false, 4);
auto line_dest_color = eatRgbColor("JOPATILI.LineDestColor", false );
auto line_dest_text_color = eatRgbColor("JOPATILI.LineDestTextColor", false );
if (!record_errors.empty()) return;
if (line_dest_icon && *line_dest_icon != static_cast<short>(*line_dest_icon))
record_errors.push_back("JOPATILI.LineDestIcon should be an integer");
if (!show_flexible_trip.empty() && show_flexible_trip != "TRUE" &&
show_flexible_trip != "FALSE" && show_flexible_trip != "REALTIME")
record_errors.push_back("JOPATILI.ShowFlexibleTrip should be in BISON E21 values [TRUE, FALSE, REALTIME]");
if (!record_errors.empty()) return;
records.journey_pattern_timing_links.emplace_back(
Kv1JourneyPatternTimingLink::Key(
data_owner_code,
line_planning_number,
journey_pattern_code,
static_cast<short>(*timing_link_order)),
user_stop_code_begin,
user_stop_code_end,
con_fin_rel_code,
dest_code,
*is_timing_stop,
display_public_line,
product_formula_type,
*get_in,
*get_out,
show_flexible_trip,
line_dest_icon,
line_dest_color,
line_dest_text_color);
}
void Kv1Parser::parsePoint() {
auto data_owner_code = eatString("POINT.DataOwnerCode", true, 10);
auto point_code = eatString("POINT.PointCode", true, 10);
eatCell ("POINT.<deprecated field #1>" );
auto point_type = eatString("POINT.PointType", true, 10);
auto coordinate_system_type = eatString("POINT.CoordinateSystemType", true, 10);
// NOTE: We deviate from the specification here once again. The specification
// notes that LocationX_EW should contain 'at least 6 positions'. Assuming
// that this is referring to the amount of digits, we have to lower this to
// 4. Otherwise, some positions in the Netherlands and Belgium are
// unrepresentable.
auto location_x_ew = eatRdCoord("POINT.LocationX_EW", true, 4);
auto location_y_ew = eatRdCoord("POINT.LocationX_EW", true, 6);
auto location_z = eatRdCoord("POINT.LocationZ", false, 0);
auto description = eatString ("POINT.Description", false, 255);
if (!record_errors.empty()) return;
records.points.emplace_back(
Kv1Point::Key(
std::move(data_owner_code),
std::move(point_code)),
std::move(point_type),
std::move(coordinate_system_type),
*location_x_ew,
*location_y_ew,
location_z,
std::move(description));
}
void Kv1Parser::parsePointOnLink() {
auto data_owner_code = eatString("POOL.DataOwnerCode", true, 10);
auto user_stop_code_begin = eatString("POOL.UserStopCodeBegin", true, 10);
auto user_stop_code_end = eatString("POOL.UserStopCodeEnd", true, 10);
eatCell ("POOL.<deprecated field #1>" );
auto point_data_owner_code = eatString("POOL.PointDataOwnerCode", true, 10);
auto point_code = eatString("POOL.PointCode", true, 10);
auto distance_since_start_of_link = eatNumber("POOL.DistanceSinceStartOfLink", true, 5);
auto segment_speed = eatNumber("POOL.SegmentSpeed", false, 4);
auto local_point_speed = eatNumber("POOL.LocalPointSpeed", false, 4);
auto description = eatString("POOL.Description", false, 255);
auto transport_type = eatString("POOL.TransportType", true, 5);
if (!record_errors.empty()) return;
records.point_on_links.emplace_back(
Kv1PointOnLink::Key(
data_owner_code,
user_stop_code_begin,
user_stop_code_end,
point_data_owner_code,
point_code,
transport_type),
*distance_since_start_of_link,
segment_speed,
local_point_speed,
std::move(description));
}
void Kv1Parser::parseIcon() {
auto data_owner_code = eatString("ICON.DataOwnerCode", true, 10);
auto icon_number = eatNumber("ICON.IconNumber", true, 4);
auto icon_uri = eatString("ICON.IconURI", true, 1024);
if (!record_errors.empty()) return;
if (*icon_number != static_cast<short>(*icon_number)) {
record_errors.push_back("ICON.IconNumber should be an integer");
return;
}
records.icons.emplace_back(
Kv1Icon::Key(
data_owner_code,
static_cast<short>(*icon_number)),
icon_uri);
}
void Kv1Parser::parseNotice() {
auto data_owner_code = eatString("NOTICE.DataOwnerCode", true, 10);
auto notice_code = eatString("NOTICE.NoticeCode", true, 20);
auto notice_content = eatString("NOTICE.NoticeContent", true, 1024);
if (!record_errors.empty()) return;
records.notices.emplace_back(
Kv1Notice::Key(
data_owner_code,
notice_code),
notice_content);
}
void Kv1Parser::parseNoticeAssignment() {
auto data_owner_code = eatString("NTCASSGNM.DataOwnerCode", true, 10);
auto notice_code = eatString("NTCASSGNM.NoticeCode", true, 20);
auto assigned_object = eatString("NTCASSGNM.AssignedObject", true, 8);
auto timetable_version_code = eatString("NTCASSGNM.TimetableVersionCode", false, 10);
auto organizational_unit_code = eatString("NTCASSGNM.OrganizationalUnitCode", false, 10);
auto schedule_code = eatString("NTCASSGNM.ScheduleCode", false, 10);
auto schedule_type_code = eatString("NTCASSGNM.ScheduleTypeCode", false, 10);
auto period_group_code = eatString("NTCASSGNM.PeriodGroupCode", false, 10);
auto specific_day_code = eatString("NTCASSGNM.SpecificDayCode", false, 10);
auto day_type = eatString("NTCASSGNM.DayType", false, 7);
auto line_planning_number = eatString("NTCASSGNM.LinePlanningNumber", true, 10);
auto journey_number = eatNumber("NTCASSGNM.JourneyNumber", false, 6);
auto stop_order = eatNumber("NTCASSGNM.StopOrder", false, 4);
auto journey_pattern_code = eatString("NTCASSGNM.JourneyPatternCode", false, 10);
auto timing_link_order = eatNumber("NTCASSGNM.TimingLinkOrder", false, 3);
auto user_stop_code = eatString("NTCASSGNM.UserStopCode", false, 10);
if (!record_errors.empty()) return;
if (journey_number && *journey_number != static_cast<short>(*journey_number))
record_errors.push_back("NTCASSGNM.JourneyNumber should be an integer");
if (journey_number && (*journey_number < 0 || *journey_number > 999'999))
record_errors.push_back("NTCASSGNM.JourneyNumber should be within the range [0-999999]");
if (stop_order && *stop_order != static_cast<short>(*stop_order))
record_errors.push_back("NTCASSGNM.StopOrder should be an integer");
if (!journey_number && (assigned_object == "PUJO" || assigned_object == "PUJOPASS"))
record_errors.push_back("NTCASSGNM.JourneyNumber is required for AssignedObject PUJO/PUJOPASS");
if (journey_pattern_code.empty() && assigned_object == "JOPATILI")
record_errors.push_back("NTCASSGNM.JourneyPatternCode is required for AssignedObject JOPATILI");
if (!record_errors.empty()) return;
records.notice_assignments.emplace_back(
data_owner_code,
notice_code,
assigned_object,
timetable_version_code,
organizational_unit_code,
schedule_code,
schedule_type_code,
period_group_code,
specific_day_code,
day_type,
line_planning_number,
static_cast<std::optional<int>>(journey_number),
static_cast<std::optional<short>>(stop_order),
journey_pattern_code,
timing_link_order,
user_stop_code);
}
void Kv1Parser::parseTimeDemandGroup() {
auto data_owner_code = eatString("TIMDEMGRP.DataOwnerCode", true, 10);
auto line_planning_number = eatString("TIMDEMGRP.LinePlanningNumber", true, 10);
auto journey_pattern_code = eatString("TIMDEMGRP.JourneyPatternCode", true, 10);
auto time_demand_group_code = eatString("TIMDEMGRP.TimeDemandGroupCode", true, 10);
if (!record_errors.empty()) return;
records.time_demand_groups.emplace_back(
Kv1TimeDemandGroup::Key(
data_owner_code,
line_planning_number,
journey_pattern_code,
time_demand_group_code));
}
void Kv1Parser::parseTimeDemandGroupRunTime() {
auto data_owner_code = eatString("TIMDEMRNT.DataOwnerCode", true, 10);
auto line_planning_number = eatString("TIMDEMRNT.LinePlanningNumber", true, 10);
auto journey_pattern_code = eatString("TIMDEMRNT.JourneyPatternCode", true, 10);
auto time_demand_group_code = eatString("TIMDEMRNT.TimeDemandGroupCode", true, 10);
auto timing_link_order = eatNumber("TIMDEMRNT.TimingLinkOrder", true, 3);
auto user_stop_code_begin = eatString("TIMDEMRNT.UserStopCodeBegin", true, 10);
auto user_stop_code_end = eatString("TIMDEMRNT.UserStopCodeEnd", true, 10);
auto total_drive_time = eatNumber("TIMDEMRNT.TotalDriveTime", true, 5);
auto drive_time = eatNumber("TIMDEMRNT.DriveTime", true, 5);
auto expected_delay = eatNumber("TIMDEMRNT.ExpectedDelay", false, 5);
auto layover_time = eatNumber("TIMDEMRNT.LayOverTime", false, 5);
auto stop_wait_time = eatNumber("TIMDEMRNT.StopWaitTime", true, 5);
auto minimum_stop_time = eatNumber("TIMDEMRNT.MinimumStopTime", false, 5);
if (!record_errors.empty()) return;
if (timing_link_order && *timing_link_order != static_cast<short>(*timing_link_order)) {
record_errors.push_back("TIMDEMRNT.TimingLinkOrder should be an integer");
return;
}
records.time_demand_group_run_times.emplace_back(
Kv1TimeDemandGroupRunTime::Key(
data_owner_code,
line_planning_number,
journey_pattern_code,
time_demand_group_code,
static_cast<short>(*timing_link_order)),
user_stop_code_begin,
user_stop_code_end,
*total_drive_time,
*drive_time,
expected_delay,
layover_time,
*stop_wait_time,
minimum_stop_time);
}
void Kv1Parser::parsePeriodGroup() {
auto data_owner_code = eatString("PEGR.DataOwnerCode", true, 10);
auto period_group_code = eatString("PEGR.PeriodGroupCode", true, 10);
auto description = eatString("PEGR.Description", false, 255);
if (!record_errors.empty()) return;
records.period_groups.emplace_back(
Kv1PeriodGroup::Key(
data_owner_code,
period_group_code),
description);
}
void Kv1Parser::parseSpecificDay() {
auto data_owner_code = eatString("SPECDAY.DataOwnerCode", true, 10);
auto specific_day_code = eatString("SPECDAY.SpecificDayCode", true, 10);
auto name = eatString("SPECDAY.Name", true, 50);
auto description = eatString("SPECDAY.Description", false, 255);
if (!record_errors.empty()) return;
records.specific_days.emplace_back(
Kv1SpecificDay::Key(
data_owner_code,
specific_day_code),
name,
description);
}
void Kv1Parser::parseTimetableVersion() {
auto data_owner_code = eatString("TIVE.DataOwnerCode", true, 10);
auto organizational_unit_code = eatString("TIVE.OrganizationalUnitCode", true, 10);
auto timetable_version_code = eatString("TIVE.TimetableVersionCode", true, 10);
auto period_group_code = eatString("TIVE.PeriodGroupCode", true, 10);
auto specific_day_code = eatString("TIVE.SpecificDayCode", true, 10);
auto valid_from_raw = eatString("TIVE.ValidFrom", true, 10);
auto timetable_version_type = eatString("TIVE.TimetableVersionType", true, 10);
auto valid_thru_raw = eatString("TIVE.ValidThru", false, 10);
auto description = eatString("TIVE.Description", false, 255);
if (!record_errors.empty()) return;
auto valid_from = parseYyyymmdd(valid_from_raw);
if (!valid_from)
record_errors.push_back("TIVE.ValidFrom has invalid format, should be YYYY-MM-DD");
std::optional<std::chrono::year_month_day> valid_thru;
if (!valid_thru_raw.empty()) {
valid_thru = parseYyyymmdd(valid_thru_raw);
if (!valid_thru) {
record_errors.push_back("TIVE.ValidFrom has invalid format, should be YYYY-MM-DD");
}
}
if (!description.empty())
record_errors.push_back("TIVE.Description should be empty");
if (!record_errors.empty()) return;
records.timetable_versions.emplace_back(
Kv1TimetableVersion::Key(
data_owner_code,
organizational_unit_code,
timetable_version_code,
period_group_code,
specific_day_code),
*valid_from,
timetable_version_type,
valid_thru,
description);
}
void Kv1Parser::parsePublicJourney() {
auto data_owner_code = eatString ("PUJO.DataOwnerCode", true, 10);
auto timetable_version_code = eatString ("PUJO.TimetableVersionCode", true, 10);
auto organizational_unit_code = eatString ("PUJO.OrganizationalUnitCode", true, 10);
auto period_group_code = eatString ("PUJO.PeriodGroupCode", true, 10);
auto specific_day_code = eatString ("PUJO.SpecificDayCode", true, 10);
auto day_type = eatString ("PUJO.DayType", true, 7);
auto line_planning_number = eatString ("PUJO.LinePlanningNumber", true, 10);
auto journey_number = eatNumber ("PUJO.JourneyNumber", true, 6);
auto time_demand_group_code = eatString ("PUJO.TimeDemandGroupCode", true, 10);
auto journey_pattern_code = eatString ("PUJO.JourneyPatternCode", true, 10);
auto departure_time_raw = eatString ("PUJO.DepartureTime", true, 8);
auto wheelchair_accessible = eatString ("PUJO.WheelChairAccessible", true, 13);
auto data_owner_is_operator = eatBoolean("PUJO.DataOwnerIsOperator", true );
auto planned_monitored = eatBoolean("PUJO.PlannedMonitored", true );
auto product_formula_type = eatNumber ("PUJO.ProductFormulaType", false, 4);
auto show_flexible_trip = eatString ("PUJO.ShowFlexibleTrip", false, 8);
if (!record_errors.empty()) return;
auto departure_time = parseHhmmss(departure_time_raw);
if (!departure_time)
record_errors.push_back("PUJO.DepartureTime has a bad format");
if (*journey_number < 0 || *journey_number > 999'999)
record_errors.push_back("PUJO.JourneyNumber should be within the range [0-999999]");
if (*journey_number != static_cast<int>(*journey_number))
record_errors.push_back("PUJO.JourneyNumber should be an integer");
if (product_formula_type && *product_formula_type != static_cast<short>(*product_formula_type))
record_errors.push_back("PUJO.ProductFormulaType should be an integer");
if (wheelchair_accessible != "ACCESSIBLE" && wheelchair_accessible != "NOTACCESSIBLE" && wheelchair_accessible != "UNKNOWN")
record_errors.push_back("PUJO.WheelChairAccessible should be in BISON E3 values [ACCESSIBLE, NOTACCESSIBLE, UNKNOWN]");
if (!show_flexible_trip.empty() && show_flexible_trip != "TRUE" &&
show_flexible_trip != "FALSE" && show_flexible_trip != "REALTIME")
record_errors.push_back("PUJO.ShowFlexibleTrip should be in BISON E21 values [TRUE, FALSE, REALTIME]");
if (!record_errors.empty()) return;
records.public_journeys.emplace_back(
Kv1PublicJourney::Key(
data_owner_code,
timetable_version_code,
organizational_unit_code,
period_group_code,
specific_day_code,
day_type,
line_planning_number,
static_cast<int>(*journey_number)),
time_demand_group_code,
journey_pattern_code,
*departure_time,
wheelchair_accessible,
*data_owner_is_operator,
*planned_monitored,
product_formula_type,
show_flexible_trip);
}
void Kv1Parser::parsePeriodGroupValidity() {
auto data_owner_code = eatString("PEGRVAL.DataOwnerCode", true, 10);
auto organizational_unit_code = eatString("PEGRVAL.OrganizationalUnitCode", true, 10);
auto period_group_code = eatString("PEGRVAL.PeriodGroupCode", true, 10);
auto valid_from_raw = eatString("PEGRVAL.ValidFrom", true, 10);
auto valid_thru_raw = eatString("PEGRVAL.ValidThru", true, 10);
if (!record_errors.empty()) return;
auto valid_from = parseYyyymmdd(valid_from_raw);
auto valid_thru = parseYyyymmdd(valid_thru_raw);
if (!valid_from)
record_errors.push_back("PEGRVAL.ValidFrom has invalid format, should be YYYY-MM-DD");
if (!valid_thru)
record_errors.push_back("PEGRVAL.ValidThru has invalid format, should be YYYY-MM-DD");
if (!record_errors.empty()) return;
records.period_group_validities.emplace_back(
Kv1PeriodGroupValidity::Key(
data_owner_code,
organizational_unit_code,
period_group_code,
*valid_from),
*valid_thru);
}
void Kv1Parser::parseExceptionalOperatingDay() {
auto data_owner_code = eatString("EXCOPDAY.DataOwnerCode", true, 10);
auto organizational_unit_code = eatString("EXCOPDAY.OrganizationalUnitCode", true, 10);
auto valid_date_raw = eatString("EXCOPDAY.ValidDate", true, 23);
auto day_type_as_on = eatString("EXCOPDAY.DayTypeAsOn", true, 7);
auto specific_day_code = eatString("EXCOPDAY.SpecificDayCode", true, 10);
auto period_group_code = eatString("EXCOPDAY.PeriodGroupCode", false, 10);
auto description = eatString("EXCOPDAY.Description", false, 255);
if (!record_errors.empty()) return;
std::string_view error;
auto valid_date = parseDateTime(valid_date_raw, amsterdam, &error);
if (!valid_date) {
record_errors.push_back(std::format("EXCOPDAY.ValidDate has an bad format (value: {}): {}", valid_date_raw, error));
return;
}
records.exceptional_operating_days.emplace_back(
Kv1ExceptionalOperatingDay::Key(
data_owner_code,
organizational_unit_code,
*valid_date),
day_type_as_on,
specific_day_code,
period_group_code,
description);
}
void Kv1Parser::parseScheduleVersion() {
auto data_owner_code = eatString("SCHEDVERS.DataOwnerCode", true, 10);
auto organizational_unit_code = eatString("SCHEDVERS.OrganizationalUnitCode", true, 10);
auto schedule_code = eatString("SCHEDVERS.ScheduleCode", true, 10);
auto schedule_type_code = eatString("SCHEDVERS.ScheduleTypeCode", true, 10);
auto valid_from_raw = eatString("SCHEDVERS.ValidFrom", true, 10);
auto valid_thru_raw = eatString("SCHEDVERS.ValidThru", false, 10);
auto description = eatString("SCHEDVERS.Description", false, 255);
if (!record_errors.empty()) return;
auto valid_from = parseYyyymmdd(valid_from_raw);
if (!valid_from)
record_errors.push_back("SCHEDVERS.ValidFrom has invalid format, should be YYYY-MM-DD");
std::optional<std::chrono::year_month_day> valid_thru;
if (!valid_thru_raw.empty()) {
valid_thru = parseYyyymmdd(valid_thru_raw);
if (!valid_thru) {
record_errors.push_back("SCHEDVERS.ValidFrom has invalid format, should be YYYY-MM-DD");
}
}
if (!description.empty())
record_errors.push_back("SCHEDVERS.Description should be empty");
if (!record_errors.empty()) return;
records.schedule_versions.emplace_back(
Kv1ScheduleVersion::Key(
data_owner_code,
organizational_unit_code,
schedule_code,
schedule_type_code),
*valid_from,
valid_thru,
description);
}
void Kv1Parser::parsePublicJourneyPassingTimes() {
auto data_owner_code = eatString ("PUJOPASS.DataOwnerCode", true, 10);
auto organizational_unit_code = eatString ("PUJOPASS.OrganizationalUnitCode", true, 10);
auto schedule_code = eatString ("PUJOPASS.ScheduleCode", true, 10);
auto schedule_type_code = eatString ("PUJOPASS.ScheduleTypeCode", true, 10);
auto line_planning_number = eatString ("PUJOPASS.LinePlanningNumber", true, 10);
auto journey_number = eatNumber ("PUJOPASS.JourneyNumber", true, 6);
auto stop_order = eatNumber ("PUJOPASS.StopOrder", true, 4);
auto journey_pattern_code = eatString ("PUJOPASS.JourneyPatternCode", true, 10);
auto user_stop_code = eatString ("PUJOPASS.UserStopCode", true, 10);
auto target_arrival_time_raw = eatString ("PUJOPASS.TargetArrivalTime", false, 8);
auto target_departure_time_raw = eatString ("PUJOPASS.TargetDepartureTime", false, 8);
auto wheelchair_accessible = eatString ("PUJOPASS.WheelChairAccessible", true, 13);
auto data_owner_is_operator = eatBoolean("PUJOPASS.DataOwnerIsOperator", true );
auto planned_monitored = eatBoolean("PUJOPASS.PlannedMonitored", true );
auto product_formula_type = eatNumber ("PUJOPASS.ProductFormulaType", false, 4);
auto show_flexible_trip = eatString ("PUJOPASS.ShowFlexibleTrip", false, 8);
if (!record_errors.empty()) return;
if (*journey_number < 0 || *journey_number > 999'999)
record_errors.push_back("PUJOPASS.JourneyNumber should be within the range [0-999999]");
if (*journey_number != static_cast<int>(*journey_number))
record_errors.push_back("PUJOPASS.JourneyNumber should be an integer");
if (*stop_order != static_cast<short>(*stop_order))
record_errors.push_back("PUJOPASS.StopOrder should be an integer");
if (product_formula_type && *product_formula_type != static_cast<short>(*product_formula_type))
record_errors.push_back("PUJOPASS.ProductFormulaType should be an integer");
if (wheelchair_accessible != "ACCESSIBLE" && wheelchair_accessible != "NOTACCESSIBLE" && wheelchair_accessible != "UNKNOWN")
record_errors.push_back("PUJOPASS.WheelChairAccessible should be in BISON E3 values [ACCESSIBLE, NOTACCESSIBLE, UNKNOWN]");
if (!show_flexible_trip.empty() && show_flexible_trip != "TRUE" &&
show_flexible_trip != "FALSE" && show_flexible_trip != "REALTIME")
record_errors.push_back("PUJOPASS.ShowFlexibleTrip should be in BISON E21 values [TRUE, FALSE, REALTIME]");
std::optional<std::chrono::hh_mm_ss<std::chrono::seconds>> target_arrival_time;
if (!target_arrival_time_raw.empty()) {
target_arrival_time = parseHhmmss(target_arrival_time_raw);
if (!target_arrival_time) {
record_errors.push_back("PUJOPASS.TargetArrivalTime has invalid format, should be HH:MM:SS");
}
}
std::optional<std::chrono::hh_mm_ss<std::chrono::seconds>> target_departure_time;
if (!target_departure_time_raw.empty()) {
target_departure_time = parseHhmmss(target_departure_time_raw);
if (!target_departure_time) {
record_errors.push_back("PUJOPASS.TargetDepartureTime has invalid format, should be HH:MM:SS");
}
}
if (!record_errors.empty()) return;
records.public_journey_passing_times.emplace_back(
Kv1PublicJourneyPassingTimes::Key(
data_owner_code,
organizational_unit_code,
schedule_code,
schedule_type_code,
line_planning_number,
static_cast<int>(*journey_number),
static_cast<short>(*stop_order)),
journey_pattern_code,
user_stop_code,
target_arrival_time,
target_departure_time,
wheelchair_accessible,
*data_owner_is_operator,
*planned_monitored,
product_formula_type,
show_flexible_trip);
}
void Kv1Parser::parseOperatingDay() {
auto data_owner_code = eatString("OPERDAY.DataOwnerCode", true, 10);
auto organizational_unit_code = eatString("OPERDAY.OrganizationalUnitCode", true, 10);
auto schedule_code = eatString("OPERDAY.ScheduleCode", true, 10);
auto schedule_type_code = eatString("OPERDAY.ScheduleTypeCode", true, 10);
auto valid_date_raw = eatString("OPERDAY.ValidDate", true, 10);
auto description = eatString("OPERDAY.Description", false, 255);
if (!record_errors.empty()) return;
auto valid_date = parseYyyymmdd(valid_date_raw);
if (!valid_date)
record_errors.push_back("OPERDAY.ValidDate has invalid format, should be YYYY-MM-DD");
if (!record_errors.empty()) return;
records.operating_days.emplace_back(
Kv1OperatingDay::Key(
data_owner_code,
organizational_unit_code,
schedule_code,
schedule_type_code,
*valid_date),
description);
}
const std::unordered_map<std::string_view, Kv1Parser::ParseFunc> Kv1Parser::type_parsers{
{ "ORUN", &Kv1Parser::parseOrganizationalUnit },
{ "ORUNORUN", &Kv1Parser::parseHigherOrganizationalUnit },
{ "USRSTOP", &Kv1Parser::parseUserStopPoint },
{ "USRSTAR", &Kv1Parser::parseUserStopArea },
{ "TILI", &Kv1Parser::parseTimingLink },
{ "LINK", &Kv1Parser::parseLink },
{ "LINE", &Kv1Parser::parseLine },
{ "DEST", &Kv1Parser::parseDestination },
{ "JOPA", &Kv1Parser::parseJourneyPattern },
{ "CONFINREL", &Kv1Parser::parseConcessionFinancerRelation },
{ "CONAREA", &Kv1Parser::parseConcessionArea },
{ "FINANCER", &Kv1Parser::parseFinancer },
{ "JOPATILI", &Kv1Parser::parseJourneyPatternTimingLink },
{ "POINT", &Kv1Parser::parsePoint },
{ "POOL", &Kv1Parser::parsePointOnLink },
{ "ICON", &Kv1Parser::parseIcon },
{ "NOTICE", &Kv1Parser::parseNotice },
{ "NTCASSGNM", &Kv1Parser::parseNoticeAssignment },
{ "TIMDEMGRP", &Kv1Parser::parseTimeDemandGroup },
{ "TIMDEMRNT", &Kv1Parser::parseTimeDemandGroupRunTime },
{ "PEGR", &Kv1Parser::parsePeriodGroup },
{ "SPECDAY", &Kv1Parser::parseSpecificDay },
{ "TIVE", &Kv1Parser::parseTimetableVersion },
{ "PUJO", &Kv1Parser::parsePublicJourney },
{ "PEGRVAL", &Kv1Parser::parsePeriodGroupValidity },
{ "EXCOPDAY", &Kv1Parser::parseExceptionalOperatingDay },
{ "SCHEDVERS", &Kv1Parser::parseScheduleVersion },
{ "PUJOPASS", &Kv1Parser::parsePublicJourneyPassingTimes },
{ "OPERDAY", &Kv1Parser::parseOperatingDay },
};
