KItinerary

fcbticket2.cpp
1/*
2 SPDX-FileCopyrightText: 2022-2025 Volker Krause <vkrause@kde.org>
3 SPDX-License-Identifier: LGPL-2.0-or-later
4*/
5
6#include "fcbticket2.h"
7#include "fcbreader_p.h"
8#include "fcbutil.h"
9
10#include "logging.h"
11#include "asn1/uperdecoder.h"
12
13constexpr inline auto FCB_TIME_MAX = 1439;
14constexpr inline auto FCB_BEGIN_DATE_MIN = -1;
15constexpr inline auto FCB_END_DATE_MIN = -1;
16constexpr inline auto FCB_DATE_MAX = 370;
17
18constexpr inline auto FCB_PRODUCT_ID_NUM_MAX = 65535;
19
20using namespace KItinerary;
21
22void Fcb::v2::ExtensionData::decode(KItinerary::UPERDecoder &decoder)
23{
24 decodeSequence(decoder);
25 extensionId = decoder.readIA5String();
26 extensionData = decoder.readOctetString();
27}
28
29void Fcb::v2::GeoCoordinateType::decode(UPERDecoder &decoder)
30{
31 decodeSequence(decoder);
32 FCB_READ_ENUM(geoUnit);
33 FCB_READ_ENUM(coordinateSystem);
34 FCB_READ_ENUM(hemisphereLongitude);
35 FCB_READ_ENUM(hemisphereLongitude);
36 longitude = decoder.readUnconstrainedWholeNumber();
37 latitude = decoder.readUnconstrainedWholeNumber();
38 FCB_READ_ENUM(accuracy);
39}
40
41void Fcb::v2::DeltaCoordinate::decode(UPERDecoder &decoder)
42{
43 decodeSequence(decoder);
44 longitude = decoder.readUnconstrainedWholeNumber();
45 latitude = decoder.readUnconstrainedWholeNumber();
46}
47
48void Fcb::v2::IssuingData::decode(UPERDecoder &decoder)
49{
50 decodeSequence(decoder);
51 FCB_READ_INT_IA5_PAIR(securityProvider, 1, 32000);
52 FCB_READ_INT_IA5_PAIR(issuer, 1, 32000);
53 issuingYear = decoder.readConstrainedWholeNumber(2016, 2269);
54 issuingDay = decoder.readConstrainedWholeNumber(1, 366);
55 FCB_READ_TIME(issuingTime);
56 FCB_READ_UTF8STRING(issuerName);
57 specimen = decoder.readBoolean();
58 securePaperTicket = decoder.readBoolean();
59 activated = decoder.readBoolean();
60 FCB_READ_IA5STRING_CONSTRAINED(currency, 3, 3);
61 FCB_READ_CONSTRAINED_INT(currencyFract, 1, 3);
62 FCB_READ_IA5STRING(issuerPNR);
63 FCB_READ_CUSTOM(extension);
64 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(issuedOnTrain);
65 FCB_READ_UNCONSTRAINED_INT(issuedOnLine);
66 FCB_READ_CUSTOM(pointOfSale);
67}
68
69QDateTime Fcb::v2::IssuingData::issueingDateTime() const
70{
71 return FcbUtil::issuingDateTime(issuingYear, issuingDay, issuingTimeValue());
72}
73
74void Fcb::v2::CustomerStatusType::decode(UPERDecoder &decoder)
75{
76 decodeSequence(decoder);
77 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(statusProvider);
78 FCB_READ_UNCONSTRAINED_INT(customerStatus);
79 FCB_READ_IA5STRING(customerStatusDescr);
80}
81
82void Fcb::v2::TravelerType::decode(UPERDecoder &decoder)
83{
84 decodeSequence(decoder);
85 FCB_READ_UTF8STRING(firstName);
86 FCB_READ_UTF8STRING(secondName);
87 FCB_READ_UTF8STRING(lastName);
88 FCB_READ_IA5STRING(idCard);
89 FCB_READ_IA5STRING(passportId);
90 FCB_READ_IA5STRING(title);
91 FCB_READ_ENUM(gender);
92 FCB_READ_IA5STRING(customerIdIA5);
93 FCB_READ_UNCONSTRAINED_INT(customerIdNum);
94 FCB_READ_CONSTRAINED_INT(yearOfBirth, 1901, 2155);
95 FCB_READ_CONSTRAINED_INT(monthOfBirth, 1, 12);
96 FCB_READ_CONSTRAINED_INT(dayOfBirthInMonth, 1, 31);
97 ticketHolder = decoder.readBoolean();
98 FCB_READ_ENUM(passengerType);
99 if (passengerWithReducedMobilityIsSet()) {
100 passengerWithReducedMobility = decoder.readBoolean();
101 }
102 FCB_READ_CONSTRAINED_INT(countryOfResidence, 1, 999);
103 FCB_READ_CONSTRAINED_INT(countryOfPassport, 1, 999);
104 FCB_READ_CONSTRAINED_INT(countryOfIdCard, 1, 999);
105 FCB_READ_SEQUENCE_OF_CUSTOM(status);
106}
107
108void Fcb::v2::TravelerData::decode(UPERDecoder &decoder)
109{
110 decodeSequence(decoder);
111 FCB_READ_SEQUENCE_OF_CUSTOM(traveler);
112 FCB_READ_IA5STRING_CONSTRAINED(preferredLanguage, 2, 2);
113 FCB_READ_UTF8STRING(groupName);
114}
115
116void Fcb::v2::TrainLinkType::decode(UPERDecoder &decoder)
117{
118 decodeSequence(decoder);
119 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(train);
120 travelDate = decoder.readConstrainedWholeNumber(-1, FCB_DATE_MAX);
121 FCB_READ_TIME(departureTime);
122 FCB_READ_CONSTRAINED_INT(departureUTCOffset, -60, 60);
123 FCB_READ_INT_IA5_PAIR(fromStation, 1, 9999999);
124 FCB_READ_INT_IA5_PAIR(toStation, 1, 9999999);
125 FCB_READ_UTF8STRING(fromStationNameUTF8);
126 FCB_READ_UTF8STRING(toStationNameUTF8);
127}
128
129QDateTime Fcb::v2::TrainLinkType::departureDateTime(const QDateTime &issueingDateTime) const
130{
131 return FcbUtil::decodeDifferentialTime(issueingDateTime, travelDate, departureTime, departureUTCOffsetValue());
132}
133
134void Fcb::v2::ViaStationType::decode(UPERDecoder &decoder)
135{
136 decodeSequence(decoder);
137 FCB_READ_ENUM(stationCodeTable);
138 FCB_READ_INT_IA5_PAIR(station, 1, 9999999);
139 FCB_READ_SEQUENCE_OF_CUSTOM(alternativeRoutes);
140 FCB_READ_SEQUENCE_OF_CUSTOM(route);
141 border = decoder.readBoolean();
142 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(carrierNum, 1, 32000);
143 FCB_READ_SEQUENCE_OF_IA5STRING(carrierIA5);
144 FCB_READ_UNCONSTRAINED_INT(seriesId);
145 FCB_READ_UNCONSTRAINED_INT(routeId);
146}
147
148void Fcb::v2::ZoneType::decode(UPERDecoder &decoder)
149{
150 decodeSequence(decoder);
151 FCB_READ_INT_IA5_PAIR(carrier, 1, 32000);
152 FCB_READ_ENUM(stationCodeTable);
153 FCB_READ_INT_IA5_PAIR(entryStation, 1, 9999999);
154 FCB_READ_INT_IA5_PAIR(terminatingStation, 1, 9999999);
155 FCB_READ_UNCONSTRAINED_INT(city);
156 FCB_READ_SEQUENCE_OF_UNCONTRAINED_INT(zoneId);
157 FCB_READ_OCTETSTRING(binaryZoneId);
158 FCB_READ_IA5STRING(nutsCode);
159}
160
161void Fcb::v2::LineType::decode(UPERDecoder &decoder)
162{
163 decodeSequence(decoder);
164 FCB_READ_INT_IA5_PAIR(carrier, 1, 32000);
165 FCB_READ_SEQUENCE_OF_UNCONTRAINED_INT(lineId);
166 FCB_READ_ENUM(stationCodeTable);
167 FCB_READ_INT_IA5_PAIR(entryStation, 1, 9999999);
168 FCB_READ_INT_IA5_PAIR(terminatingStation, 1, 9999999);
169 FCB_READ_CONSTRAINED_INT(city, 1, 9999999);
170}
171
172void Fcb::v2::PolygoneType::decode(UPERDecoder &decoder)
173{
174 decodeSequence(decoder);
175 firstEdge.decode(decoder);
176 edges = decoder.readSequenceOf<DeltaCoordinate>();
177}
178
179void Fcb::v2::RegionalValidityType::decode(UPERDecoder &decoder)
180{
181 value = decoder.readChoiceWithExtensionMarker<TrainLinkType, ViaStationType, ZoneType, LineType, PolygoneType>();
182}
183
184void Fcb::v2::ReturnRouteDescriptionType::decode(UPERDecoder &decoder)
185{
186 decodeSequence(decoder);
187 FCB_READ_INT_IA5_PAIR(fromStation, 1, 9999999);
188 FCB_READ_INT_IA5_PAIR(toStation, 1, 9999999);
189 FCB_READ_UTF8STRING(fromStationNameUTF8);
190 FCB_READ_UTF8STRING(toStationNameUTF8);
191 FCB_READ_UTF8STRING(validReturnRegionDesc);
192 FCB_READ_SEQUENCE_OF_CUSTOM(validReturnRegion);
193}
194
195void Fcb::v2::RouteSectionType::decode(UPERDecoder &decoder)
196{
197 decodeSequence(decoder);
198 FCB_READ_ENUM(stationCodeTable);
199 FCB_READ_INT_IA5_PAIR(fromStation, 1, 9999999);
200 FCB_READ_INT_IA5_PAIR(toStation, 1, 9999999);
201 FCB_READ_UTF8STRING(fromStationNameUTF8);
202 FCB_READ_UTF8STRING(toStationNameUTF8);
203}
204
205void Fcb::v2::SeriesDetailType::decode(UPERDecoder &decoder)
206{
207 decodeSequence(decoder);
208 FCB_READ_CONSTRAINED_INT(supplyingCarrier, 1, 32000);
209 FCB_READ_CONSTRAINED_INT(offerIdentification, 1, 99);
210 FCB_READ_UNCONSTRAINED_INT(series);
211}
212
213void Fcb::v2::CardReferenceType::decode(UPERDecoder &decoder)
214{
215 decodeSequence(decoder);
216 FCB_READ_INT_IA5_PAIR(cardIssuer, 1, 32000);
217 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(cardId);
218 FCB_READ_UTF8STRING(cardName);
219 FCB_READ_UNCONSTRAINED_INT(cardType);
220 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(leadingCardId);
221 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(trailingCardId);
222}
223
224void Fcb::v2::PlacesType::decode(KItinerary::UPERDecoder &decoder)
225{
226 decodeSequence(decoder);
227 FCB_READ_IA5STRING(coach);
228 FCB_READ_IA5STRING(placeString);
229 FCB_READ_UTF8STRING(placeDescription);
230 FCB_READ_SEQUENCE_OF_IA5STRING(placeIA5);
231 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(placeNum, 1, 254);
232}
233
234void Fcb::v2::CompartmentDetailsType::decode(UPERDecoder &decoder)
235{
236 decodeSequence(decoder);
237 FCB_READ_CONSTRAINED_INT(coachType, 1, 99);
238 FCB_READ_CONSTRAINED_INT(compartmentType, 1, 99);
239 FCB_READ_CONSTRAINED_INT(specialAllocation, 1, 99);
240 FCB_READ_UTF8STRING(coachTypeDescr);
241 FCB_READ_UTF8STRING(compartmentTypeDescr);
242 FCB_READ_UTF8STRING(specialAllocationDescr);
243 FCB_READ_ENUM(position);
244}
245
246void Fcb::v2::BerthDetailData::decode(UPERDecoder &decoder)
247{
248 decodeSequence(decoder);
249 berthType = decoder.readEnumerated<BerthTypeType>();
250 numberOfBerths = decoder.readConstrainedWholeNumber(1, 999);
251 FCB_READ_ENUM(gender);
252}
253
254void Fcb::v2::TariffType::decode(UPERDecoder &decoder)
255{
256 decodeSequence(decoder);
257 FCB_READ_CONSTRAINED_INT(numberOfPassengers, 1, 200);
258 FCB_READ_ENUM(passengerType);
259 FCB_READ_CONSTRAINED_INT(ageBelow, 1, 64);
260 FCB_READ_CONSTRAINED_INT(ageAbove, 1, 128);
261 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(travelerid, 1, 254);
262 restrictedToCountryOfResidence = decoder.readBoolean();
263 FCB_READ_CUSTOM(restrictedToRouteSection);
264 FCB_READ_CUSTOM(seriesDataDetails);
265 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(tariffId);
266 FCB_READ_UTF8STRING(tariffDesc);
267 FCB_READ_SEQUENCE_OF_CUSTOM(reductionCard);
268}
269
270void Fcb::v2::VatDetailType::decode(UPERDecoder &decoder)
271{
272 decodeSequence(decoder);
273 country = decoder.readConstrainedWholeNumber(1, 999);
274 percentage = decoder.readConstrainedWholeNumber(0, 999);
275 FCB_READ_UNCONSTRAINED_INT(amount);
276 FCB_READ_IA5STRING(vatId);
277}
278
279void Fcb::v2::IncludedOpenTicketType::decode(UPERDecoder &decoder)
280{
281 decodeSequence(decoder);
282 FCB_READ_INT_IA5_PAIR(productOwner, 1, 32000);
283 FCB_READ_INT_IA5_PAIR(productId, 0, FCB_PRODUCT_ID_NUM_MAX);
284 FCB_READ_UNCONSTRAINED_INT(externalIssuerId);
285 FCB_READ_UNCONSTRAINED_INT(issuerAutorizationId);
286 FCB_READ_ENUM(stationCodeTable);
287 FCB_READ_SEQUENCE_OF_CUSTOM(validRegion);
288 FCB_READ_CONSTRAINED_INT(validFromDay, FCB_BEGIN_DATE_MIN, 700);
289 FCB_READ_TIME(validFromTime);
290 FCB_READ_CONSTRAINED_INT(validFromUTCOffset, -60, 60);
291 FCB_READ_CONSTRAINED_INT(validUntilDay, FCB_END_DATE_MIN, FCB_DATE_MAX);
292 FCB_READ_TIME(validUntilTime);
293 FCB_READ_CONSTRAINED_INT(validUntilUTCOffset, -60, 60);
294 FCB_READ_ENUM(classCode);
295 FCB_READ_IA5STRING_CONSTRAINED(serviceLevel, 1, 2);
296 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(carrierNum, 1, 32000);
297 FCB_READ_SEQUENCE_OF_IA5STRING(carrierIA5);
298 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(includedServiceBrands, 1, 32000);
299 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(excludedServiceBrands, 1, 32000);
300 FCB_READ_SEQUENCE_OF_CUSTOM(tariffs);
301 FCB_READ_UTF8STRING(infoText);
302 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(includedTransportType, 0, 31);
303 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(excludedTransportType, 0, 31);
304 FCB_READ_CUSTOM(extension);
305}
306
307void Fcb::v2::RegisteredLuggageType::decode(UPERDecoder &decoder)
308{
309 decodeSequence(decoder);
310 FCB_READ_IA5STRING(registrationId);
311 FCB_READ_CONSTRAINED_INT(maxWeight, 1, 99);
312 FCB_READ_CONSTRAINED_INT(maxSize, 1, 300);
313}
314
315void Fcb::v2::LuggageRestrictionType::decode(UPERDecoder &decoder)
316{
317 decodeSequence(decoder);
318 FCB_READ_CONSTRAINED_INT(maxHandLuggagePieces, 0, 99);
319 FCB_READ_CONSTRAINED_INT(maxNonHandLuggagePieces, 0, 99);
320 FCB_READ_SEQUENCE_OF_CUSTOM(registeredLuggage);
321}
322
323void Fcb::v2::ReservationData::decode(UPERDecoder &decoder)
324{
325 decodeSequence(decoder);
326 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(train);
327 FCB_READ_CONSTRAINED_INT(departureDate, -1, FCB_DATE_MAX);
328 FCB_READ_IA5STRING(referenceIA5);
329 FCB_READ_UNCONSTRAINED_INT(referenceNum);
330 FCB_READ_INT_IA5_PAIR(productOwner, 1, 32000);
331 FCB_READ_INT_IA5_PAIR(productId, 0, FCB_PRODUCT_ID_NUM_MAX);
332 FCB_READ_CONSTRAINED_INT(serviceBrand, 0, 32000);
333 FCB_READ_UTF8STRING(serviceBrandAbrUTF8);
334 FCB_READ_UTF8STRING(serviceBrandNameUTF8);
335 FCB_READ_ENUM(service);
336 FCB_READ_ENUM(stationCodeTable);
337 FCB_READ_INT_IA5_PAIR(fromStation, 1, 9999999);
338 FCB_READ_INT_IA5_PAIR(toStation, 1, 9999999);
339 FCB_READ_UTF8STRING(fromStationNameUTF8);
340 FCB_READ_UTF8STRING(toStationNameUTF8);
341 FCB_READ_TIME(departureTime);
342 FCB_READ_CONSTRAINED_INT(departureUTCOffset, -60, 60);
343 FCB_READ_CONSTRAINED_INT(arrivalDate, FCB_END_DATE_MIN, 20);
344 FCB_READ_TIME(arrivalTime);
345 FCB_READ_CONSTRAINED_INT(arrivalUTCOffset, -60, 60);
346 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(carrierNum, 1, 32000);
347 FCB_READ_SEQUENCE_OF_IA5STRING(carrierIA5);
348 FCB_READ_ENUM(classCode);
349 FCB_READ_IA5STRING_CONSTRAINED(serviceLevel, 1, 2);
350 FCB_READ_CUSTOM(places);
351 FCB_READ_CUSTOM(additionalPlaces);
352 FCB_READ_CUSTOM(bicyclePlaces);
353 FCB_READ_CUSTOM(compartmentDetails);
354 FCB_READ_CONSTRAINED_INT(numberOfOverbooked, 0, 200);
355 FCB_READ_SEQUENCE_OF_CUSTOM(berth);
356 FCB_READ_SEQUENCE_OF_CUSTOM(tariffs);
357 FCB_READ_ENUM(priceType);
358 FCB_READ_UNCONSTRAINED_INT(price);
359 FCB_READ_SEQUENCE_OF_CUSTOM(vatDetail);
360 FCB_READ_CONSTRAINED_INT(typeOfSupplement, 0, 9);
361 FCB_READ_CONSTRAINED_INT(numberOfSupplements, 0, 200);
362 FCB_READ_CUSTOM(luggage);
363 FCB_READ_UTF8STRING(infoText);
364 FCB_READ_CUSTOM(extension);
365}
366
367QDateTime Fcb::v2::ReservationData::departureDateTime(const QDateTime &issueingDateTime) const
368{
369 return FcbUtil::decodeDifferentialTime(issueingDateTime, departureDate, departureTimeValue(), departureUTCOffsetValue());
370}
371
372QDateTime Fcb::v2::ReservationData::arrivalDateTime(const QDateTime &issueingDateTime) const
373{
374 return FcbUtil::decodeDifferentialTime(departureDateTime(issueingDateTime), arrivalDate, arrivalTimeValue(), arrivalUTCOffsetValue());
375}
376
377void Fcb::v2::CarCarriageReservationData::decode(UPERDecoder &decoder)
378{
379 decodeSequence(decoder);
380 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(train);
381 FCB_READ_CONSTRAINED_INT(beginLoadingDate, -1, FCB_DATE_MAX);
382 FCB_READ_TIME(beginLoadingTime);
383 FCB_READ_TIME(endLoadingTime);
384 FCB_READ_CONSTRAINED_INT(loadingUTCOffset, -60, 60);
385 FCB_READ_IA5STRING(referenceIA5);
386 FCB_READ_UNCONSTRAINED_INT(referenceNum);
387 FCB_READ_INT_IA5_PAIR(productOwner, 1, 32000);
388 FCB_READ_INT_IA5_PAIR(productId, 0, FCB_PRODUCT_ID_NUM_MAX);
389 FCB_READ_CONSTRAINED_INT(serviceBrand, 0, 32000);
390 FCB_READ_UTF8STRING(serviceBrandAbrUTF8);
391 FCB_READ_UTF8STRING(serviceBrandNameUTF8);
392 FCB_READ_ENUM(stationCodeTable);
393 FCB_READ_INT_IA5_PAIR(fromStation, 1, 9999999);
394 FCB_READ_INT_IA5_PAIR(toStation, 1, 9999999);
395 FCB_READ_UTF8STRING(fromStationNameUTF8);
396 FCB_READ_UTF8STRING(toStationNameUTF8);
397 FCB_READ_IA5STRING(coach);
398 FCB_READ_IA5STRING(place);
399 FCB_READ_CUSTOM(compartmentDetails);
400 FCB_READ_IA5STRING(numberPlate);
401 FCB_READ_IA5STRING(trailerPlate);
402 carCategory = decoder.readConstrainedWholeNumber(0, 9);
403 FCB_READ_CONSTRAINED_INT(boatCategory, 0, 9);
404 textileRoof = decoder.readBoolean();
405 FCB_READ_ENUM(roofRackType);
406 FCB_READ_CONSTRAINED_INT(roofRackHeight, 0, 99);
407 FCB_READ_CONSTRAINED_INT(attachedBoats, 0, 2);
408 FCB_READ_CONSTRAINED_INT(attachedBicycles, 0, 4);
409 FCB_READ_CONSTRAINED_INT(attachedSurfboards, 0, 5);
410 FCB_READ_CONSTRAINED_INT(loadingListEntry, 0, 999);
411 FCB_READ_ENUM(loadingDeck);
412 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(carrierNum, 1, 32000);
413 FCB_READ_SEQUENCE_OF_IA5STRING(carrierIA5);
414 tariff.decode(decoder);
415 FCB_READ_ENUM(priceType);
416 FCB_READ_UNCONSTRAINED_INT(price);
417 FCB_READ_SEQUENCE_OF_CUSTOM(vatDetail);
418 FCB_READ_UTF8STRING(infoText);
419 FCB_READ_CUSTOM(extension);
420}
421
422void Fcb::v2::OpenTicketData::decode(UPERDecoder &decoder)
423{
424 decodeSequence(decoder);
425 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(reference);
426 FCB_READ_INT_IA5_PAIR(productOwner, 1, 32000);
427 FCB_READ_INT_IA5_PAIR(productId, 0, FCB_PRODUCT_ID_NUM_MAX);
428 FCB_READ_UNCONSTRAINED_INT(extIssuerId);
429 FCB_READ_UNCONSTRAINED_INT(issuerAutorizationId);
430 returnIncluded = decoder.readBoolean();
431 FCB_READ_ENUM(stationCodeTable);
432 FCB_READ_INT_IA5_PAIR(fromStation, 1, 9999999);
433 FCB_READ_INT_IA5_PAIR(toStation, 1, 9999999);
434 FCB_READ_UTF8STRING(fromStationNameUTF8);
435 FCB_READ_UTF8STRING(toStationNameUTF8);
436 FCB_READ_UTF8STRING(validRegionDesc);
437 FCB_READ_SEQUENCE_OF_CUSTOM(validRegion);
438 FCB_READ_CUSTOM(returnDescription);
439 FCB_READ_CONSTRAINED_INT(validFromDay, FCB_BEGIN_DATE_MIN, 700);
440 FCB_READ_TIME(validFromTime);
441 FCB_READ_CONSTRAINED_INT(validFromUTCOffset, -60, 60);
442 FCB_READ_CONSTRAINED_INT(validUntilDay, FCB_END_DATE_MIN, FCB_DATE_MAX);
443 FCB_READ_TIME(validUntilTime);
444 FCB_READ_CONSTRAINED_INT(validUntilUTCOffset, -60, 60);
445 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(activatedDay, 0, FCB_DATE_MAX);
446 FCB_READ_ENUM(classCode);
447 FCB_READ_IA5STRING_CONSTRAINED(serviceLevel, 1, 2);
448 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(carrierNum, 1, 32000);
449 FCB_READ_SEQUENCE_OF_IA5STRING(carrierIA5);
450 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(includedServiceBrands, 1, 32000);
451 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(excludedServiceBrands, 1, 32000);
452 FCB_READ_SEQUENCE_OF_CUSTOM(tariffs);
453 FCB_READ_UNCONSTRAINED_INT(price);
454 FCB_READ_SEQUENCE_OF_CUSTOM(vatDetail);
455 FCB_READ_UTF8STRING(infoText);
456 FCB_READ_SEQUENCE_OF_CUSTOM(includedAddOns);
457 FCB_READ_CUSTOM(luggage);
458 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(includedTransportType, 0, 31);
459 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(excludedTransportType, 0, 31);
460 FCB_READ_CUSTOM(extension);
461}
462
463QDateTime Fcb::v2::OpenTicketData::validFrom(const QDateTime &issueingDateTime) const
464{
465 return FcbUtil::decodeDifferentialStartTime(issueingDateTime, validFromDay, validFromTimeValue(), validFromUTCOffsetValue());
466}
467
468QDateTime Fcb::v2::OpenTicketData::validUntil(const QDateTime &issueingDateTime) const
469{
470 return FcbUtil::decodeDifferentialEndTime(validFrom(issueingDateTime), validUntilDay, validUntilTimeValue(), validFromUTCOffsetValue());
471}
472
473void Fcb::v2::TimeRangeType::decode(UPERDecoder &decoder)
474{
475 decodeSequence(decoder);
476 FCB_READ_TIME(fromTime);
477 FCB_READ_TIME(untilTime);
478}
479
480void Fcb::v2::ValidityPeriodType::decode(UPERDecoder &decoder)
481{
482 decodeSequence(decoder);
483 FCB_READ_CONSTRAINED_INT(validFromDay, FCB_BEGIN_DATE_MIN, 700);
484 FCB_READ_TIME(validFromTime);
485 FCB_READ_CONSTRAINED_INT(validFromUTCOffset, -60, 60);
486 FCB_READ_CONSTRAINED_INT(validUntilDay, FCB_END_DATE_MIN, FCB_DATE_MAX);
487 FCB_READ_TIME(validUntilTime);
488 FCB_READ_CONSTRAINED_INT(validUntilUTCOffset, -60, 60);
489}
490
491void Fcb::v2::ValidityPeriodDetailType::decode(UPERDecoder &decoder)
492{
493 decodeSequence(decoder);
494 FCB_READ_SEQUENCE_OF_CUSTOM(validityPeriod);
495 FCB_READ_SEQUENCE_OF_CUSTOM(excludedTimeRange);
496}
497
498void Fcb::v2::PassData::decode(UPERDecoder &decoder)
499{
500 decodeSequence(decoder);
501 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(reference);
502 FCB_READ_INT_IA5_PAIR(productOwner, 1, 32000);
503 FCB_READ_INT_IA5_PAIR(productId, 0, FCB_PRODUCT_ID_NUM_MAX);
504 FCB_READ_CONSTRAINED_INT(passType, 1, 250);
505 FCB_READ_UTF8STRING(passDescription);
506 FCB_READ_ENUM(classCode);
507 FCB_READ_CONSTRAINED_INT(validFromDay, FCB_BEGIN_DATE_MIN, 700);
508 FCB_READ_TIME(validFromTime);
509 FCB_READ_CONSTRAINED_INT(validFromUTCOffset, -60, 60);
510 FCB_READ_CONSTRAINED_INT(validUntilDay, FCB_END_DATE_MIN, FCB_DATE_MAX);
511 FCB_READ_TIME(validUntilTime);
512 FCB_READ_CONSTRAINED_INT(validUntilUTCOffset, -60, 60);
513 FCB_READ_CUSTOM(validityPeriodDetails);
514 FCB_READ_CONSTRAINED_INT(numberOfValidityDays, 0, FCB_DATE_MAX);
515 FCB_READ_CONSTRAINED_INT(numberOfPossibleTrips, 1, 250);
516 FCB_READ_CONSTRAINED_INT(numberOfDaysOfTravel, 1, 250);
517 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(activatedDay, 0, FCB_DATE_MAX);
518 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(countries, 1, 250);
519 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(includedCarrierNum, 1, 32000);
520 FCB_READ_SEQUENCE_OF_IA5STRING(includedCarrierIA5);
521 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(excludedCarrierNum, 1, 32000);
522 FCB_READ_SEQUENCE_OF_IA5STRING(excludedCarrierIA5);
523 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(includedServiceBrands, 1, 32000);
524 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(excludedServiceBrands, 1, 32000);
525 FCB_READ_SEQUENCE_OF_CUSTOM(validRegion);
526 FCB_READ_SEQUENCE_OF_CUSTOM(tariffs);
527 FCB_READ_UNCONSTRAINED_INT(price);
528 FCB_READ_SEQUENCE_OF_CUSTOM(vatDetail);
529 FCB_READ_UTF8STRING(infoText);
530 FCB_READ_CUSTOM(extension);
531}
532
533QDateTime Fcb::v2::PassData::validFrom(const QDateTime &issueingDateTime) const
534{
535 return FcbUtil::decodeDifferentialStartTime(issueingDateTime, validFromDay, validFromTimeValue(), validFromUTCOffsetValue());
536}
537
538QDateTime Fcb::v2::PassData::validUntil(const QDateTime &issueingDateTime) const
539{
540 return FcbUtil::decodeDifferentialEndTime(validFrom(issueingDateTime), validUntilDay, validUntilTimeValue(), validUntilUTCOffsetValue());
541}
542
543void Fcb::v2::VoucherData::decode(UPERDecoder &decoder)
544{
545 decodeSequence(decoder);
546 FCB_READ_IA5STRING(referenceIA5);
547 FCB_READ_UNCONSTRAINED_INT(referenceNum);
548 FCB_READ_INT_IA5_PAIR(productOwner, 1, 32000);
549 FCB_READ_INT_IA5_PAIR(productId, 0, FCB_PRODUCT_ID_NUM_MAX);
550 validFromYear = decoder.readConstrainedWholeNumber(2016, 2269);
551 validFromDay = decoder.readConstrainedWholeNumber(0, FCB_DATE_MAX);
552 validUntilYear = decoder.readConstrainedWholeNumber(2016, 2269);
553 validUntilDay = decoder.readConstrainedWholeNumber(0, FCB_DATE_MAX);
554 FCB_READ_UNCONSTRAINED_INT(value);
555 FCB_READ_CONSTRAINED_INT(type, 1, 32000);
556 FCB_READ_UTF8STRING(infoText);
557 FCB_READ_CUSTOM(extension);
558}
559
560void Fcb::v2::CustomerCardData::decode(UPERDecoder &decoder)
561{
562 decodeSequence(decoder);
563 FCB_READ_CUSTOM(customer);
564 FCB_READ_IA5STRING(cardIdIA5);
565 FCB_READ_UNCONSTRAINED_INT(cardIdNum);
566 validFromYear = decoder.readConstrainedWholeNumber(2016, 2269);
567 FCB_READ_CONSTRAINED_INT(validFromDay, 0, FCB_DATE_MAX);
568 FCB_READ_CONSTRAINED_INT(validUntilYear, 0, 250);
569 FCB_READ_CONSTRAINED_INT(validUntilDay, 0, FCB_DATE_MAX);
570 FCB_READ_ENUM(classCode);
571 FCB_READ_CONSTRAINED_INT(cardType, 1, 1000);
572 FCB_READ_UTF8STRING(cardTypeDescr);
573 FCB_READ_UNCONSTRAINED_INT(customerStatus);
574 FCB_READ_IA5STRING(customerStatusDescr);
575 FCB_READ_SEQUENCE_OF_UNCONTRAINED_INT(includedServices);
576 FCB_READ_CUSTOM(extension);
577}
578
579QDate Fcb::v2::CustomerCardData::validFrom() const
580{
581 return FcbUtil::decodeDate(validFromYear, validFromDayValue());
582}
583
584QDate Fcb::v2::CustomerCardData::validUntil() const
585{
586 return FcbUtil::decodeDifferentialDate(validFrom(), validUntilYear, validFromDayValue());
587}
588
589void Fcb::v2::CountermarkData::decode(UPERDecoder &decoder)
590{
591 decodeSequence(decoder);
592 FCB_READ_IA5STRING(referenceIA5);
593 FCB_READ_UNCONSTRAINED_INT(referenceNum);
594 FCB_READ_INT_IA5_PAIR(productOwner, 1, 32000);
595 FCB_READ_INT_IA5_PAIR(productId, 0, FCB_PRODUCT_ID_NUM_MAX);
596 FCB_READ_IA5STRING(ticketReferenceIA5);
597 FCB_READ_UNCONSTRAINED_INT(ticketReferenceNum);
598 numberOfCountermark = decoder.readConstrainedWholeNumber(1, 200);
599 totalOfCountermarks = decoder.readConstrainedWholeNumber(1, 200);
600 groupName = decoder.readUtf8String();
601 FCB_READ_ENUM(stationCodeTable);
602 FCB_READ_INT_IA5_PAIR(fromStation, 1, 9999999);
603 FCB_READ_INT_IA5_PAIR(toStation, 1, 9999999);
604 FCB_READ_UTF8STRING(fromStationNameUTF8);
605 FCB_READ_UTF8STRING(toStationNameUTF8);
606 FCB_READ_UTF8STRING(validRegionDesc);
607 FCB_READ_SEQUENCE_OF_CUSTOM(validRegion);
608 returnIncluded = decoder.readBoolean();
609 FCB_READ_CUSTOM(returnDescription);
610 FCB_READ_CONSTRAINED_INT(validFromDay, FCB_BEGIN_DATE_MIN, 700);
611 FCB_READ_TIME(validFromTime);
612 FCB_READ_CONSTRAINED_INT(validFromUTCOffset, -60, 60);
613 FCB_READ_CONSTRAINED_INT(validUntilDay, FCB_END_DATE_MIN, FCB_DATE_MAX);
614 FCB_READ_TIME(validUntilTime);
615 FCB_READ_CONSTRAINED_INT(validUntilUTCOffset, -60, 60);
616 FCB_READ_ENUM(classCode);
617 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(carrierNum, 1, 32000);
618 FCB_READ_SEQUENCE_OF_IA5STRING(carrierIA5);
619 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(includedServiceBrands, 1, 32000);
620 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(excludedServiceBrands, 1, 32000);
621 FCB_READ_UTF8STRING(infoText);
622 FCB_READ_CUSTOM(extension);
623}
624
625void Fcb::v2::ParkingGroundData::decode(UPERDecoder &decoder)
626{
627 decodeSequence(decoder);
628 FCB_READ_IA5STRING(referenceIA5);
629 FCB_READ_UNCONSTRAINED_INT(referenceNum);
630 parkingGroundId = decoder.readIA5String();
631 fromParkingDate = decoder.readConstrainedWholeNumber(FCB_BEGIN_DATE_MIN, 370);
632 FCB_READ_CONSTRAINED_INT(untilParkingDate, 0, FCB_DATE_MAX);
633 FCB_READ_INT_IA5_PAIR(productOwner, 1, 32000);
634 FCB_READ_INT_IA5_PAIR(productId, 0, FCB_PRODUCT_ID_NUM_MAX);
635 FCB_READ_IA5STRING(accessCode);
636 location = decoder.readUtf8String();
637 FCB_READ_ENUM(stationCodeTable);
638 FCB_READ_UNCONSTRAINED_INT(stationNum);
639 FCB_READ_UTF8STRING(stationIA5);
640 FCB_READ_UTF8STRING(specialInformation);
641 FCB_READ_UTF8STRING(entryTrack);
642 FCB_READ_IA5STRING(numberPlate);
643 FCB_READ_UNCONSTRAINED_INT(price);
644 FCB_READ_SEQUENCE_OF_CUSTOM(vatDetail);
645 FCB_READ_CUSTOM(extension);
646}
647
648void Fcb::v2::FIPTicketData::decode(UPERDecoder &decoder)
649{
650 decodeSequence(decoder);
651 FCB_READ_IA5STRING(referenceIA5);
652 FCB_READ_UNCONSTRAINED_INT(referenceNum);
653 FCB_READ_INT_IA5_PAIR(productOwner, 1, 32000);
654 FCB_READ_INT_IA5_PAIR(productId, 0, FCB_PRODUCT_ID_NUM_MAX);
655 FCB_READ_CONSTRAINED_INT(validFromDay, -1, 700);
656 FCB_READ_CONSTRAINED_INT(validUntilDay, 0, FCB_DATE_MAX);
657 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(activatedDay, 0, FCB_DATE_MAX);
658 FCB_READ_SEQUENCE_OF_CONTRAINED_INT(carrierNum, 1, 32000);
659 FCB_READ_SEQUENCE_OF_IA5STRING(carrierIA5);
660 numberOfTravelDays = decoder.readConstrainedWholeNumber(1, 200);
661 includesSupplements = decoder.readBoolean();
662 FCB_READ_ENUM(classCode);
663 FCB_READ_CUSTOM(extension);
664}
665
666void Fcb::v2::StationPassageData::decode(UPERDecoder &decoder)
667{
668 decodeSequence(decoder);
669 FCB_READ_IA5STRING(referenceIA5);
670 FCB_READ_UNCONSTRAINED_INT(referenceNum);
671 FCB_READ_INT_IA5_PAIR(productOwner, 1, 32000);
672 FCB_READ_INT_IA5_PAIR(productId, 0, FCB_PRODUCT_ID_NUM_MAX);
673 FCB_READ_UTF8STRING(productName);
674 FCB_READ_ENUM(stationCodeTable);
675 FCB_READ_SEQUENCE_OF_UNCONTRAINED_INT(stationNum);
676 FCB_READ_SEQUENCE_OF_IA5STRING(stationIA5);
677 FCB_READ_SEQUENCE_OF_UTF8STRING(stationNameUTF8);
678 FCB_READ_SEQUENCE_OF_UNCONTRAINED_INT(areaCodeNum);
679 FCB_READ_SEQUENCE_OF_IA5STRING(areaCodeIA5);
680 FCB_READ_SEQUENCE_OF_UTF8STRING(areaNameUTF8);
681 validFromDay = decoder.readConstrainedWholeNumber(FCB_BEGIN_DATE_MIN, 700);
682 FCB_READ_TIME(validFromTime);
683 FCB_READ_CONSTRAINED_INT(validFromUTCOffset, -60, 60);
684 FCB_READ_CONSTRAINED_INT(validUntilDay, FCB_END_DATE_MIN, FCB_DATE_MAX);
685 FCB_READ_TIME(validUntilTime);
686 FCB_READ_CONSTRAINED_INT(validUntilUTCOffset, -60, 60);
687 FCB_READ_UNCONSTRAINED_INT(numberOfDaysValid);
688 FCB_READ_CUSTOM(extension);
689}
690
691void Fcb::v2::DelayConfirmation::decode(UPERDecoder &decoder)
692{
693 decodeSequence(decoder);
694 FCB_READ_IA5STRING(referenceIA5);
695 FCB_READ_UNCONSTRAINED_INT(referenceNum);
696 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(train);
697 FCB_READ_CONSTRAINED_INT(departureYear, 2016, 2269);
698 FCB_READ_CONSTRAINED_INT(departureDay, 1, 366);
699 FCB_READ_TIME(departureTime);
700 FCB_READ_CONSTRAINED_INT(departureUTCOffset, -60, 60);
701 FCB_READ_ENUM(stationCodeTable);
702 FCB_READ_INT_IA5_PAIR(station, 1, 9999999);
703 delay = decoder.readConstrainedWholeNumber(1, 999);
704 trainCancelled = decoder.readBoolean();
705 FCB_READ_ENUM(confirmationType);
706 FCB_READ_SEQUENCE_OF_CUSTOM(affectedTickets);
707 FCB_READ_UTF8STRING(infoText);
708 FCB_READ_CUSTOM(extension);
709}
710
711void Fcb::v2::TokenType::decode(UPERDecoder &decoder)
712{
713 decodeSequence(decoder);
714 FCB_READ_INT_IA5_PAIR_UNCONSTRAINED(tokenProvider);
715 FCB_READ_IA5STRING(tokenSpecification);
716 token = decoder.readOctetString();
717}
718
719void Fcb::v2::DocumentData::decode(UPERDecoder &decoder)
720{
721 decodeSequence(decoder);
722 FCB_READ_CUSTOM(token);
723 ticket = decoder.readChoiceWithExtensionMarker<
724 ReservationData,
725 CarCarriageReservationData,
726 OpenTicketData,
727 PassData,
728 VoucherData,
729 CustomerCardData,
730 CountermarkData,
731 ParkingGroundData,
732 FIPTicketData,
733 StationPassageData,
734 ExtensionData,
735 DelayConfirmation
736 >();
737}
738
739void Fcb::v2::TicketLinkType::decode(UPERDecoder &decoder)
740{
741 decodeSequence(decoder);
742 FCB_READ_IA5STRING(referenceIA5);
743 FCB_READ_UNCONSTRAINED_INT(referenceNum);
744 FCB_READ_UTF8STRING(issuerName);
745 FCB_READ_IA5STRING(issuerPNR);
746 FCB_READ_INT_IA5_PAIR(productOwner, 1, 32000);
747 FCB_READ_ENUM(ticketType);
748 FCB_READ_ENUM(linkMode);
749}
750
751void Fcb::v2::ControlData::decode(UPERDecoder &decoder)
752{
753 decodeSequence(decoder);
754 FCB_READ_SEQUENCE_OF_CUSTOM(identificationByCardReference);
755 identificationByIdCard = decoder.readBoolean();
756 identificationByPassportId = decoder.readBoolean();
757 FCB_READ_UNCONSTRAINED_INT(identificationItem);
758 passportValidationRequired = decoder.readBoolean();
759 onlineValidationRequired = decoder.readBoolean();
760 FCB_READ_CONSTRAINED_INT(randomDetailedValidationRequired, 0, 99);
761 ageCheckRequired = decoder.readBoolean();
762 reductionCardCheckRequired = decoder.readBoolean();
763 FCB_READ_UTF8STRING(infoText);
764 FCB_READ_SEQUENCE_OF_CUSTOM(includedTickets);
765 FCB_READ_CUSTOM(extension);
766}
767
768Fcb::v2::UicRailTicketData::UicRailTicketData() = default;
769
770Fcb::v2::UicRailTicketData::UicRailTicketData(const Uic9183Block &block)
771 : m_data(QVariant::fromValue(block))
772{
773 if (block.isNull()) {
774 return;
775 }
776 UPERDecoder decoder(BitVectorView(std::string_view(block.content(), block.contentSize())));
777 decode(decoder);
778 if (decoder.hasError()) {
779 qCWarning(Log) << decoder.errorMessage();
780 m_data = {};
781 }
782}
783
784Fcb::v2::UicRailTicketData::UicRailTicketData(const QByteArray &data)
785 : m_data(data)
786{
787 UPERDecoder decoder(BitVectorView(std::string_view(data.constData(), data.size())));
788 decode(decoder);
789 if (decoder.hasError()) {
790 qCWarning(Log) << decoder.errorMessage();
791 m_data = {};
792 }
793}
794
795void Fcb::v2::UicRailTicketData::decode(UPERDecoder &decoder)
796{
797 decodeSequence(decoder);
798 issuingDetail.decode(decoder);
799 FCB_READ_CUSTOM(travelerDetail);
800 FCB_READ_SEQUENCE_OF_CUSTOM(transportDocument)
801 FCB_READ_CUSTOM(controlDetail)
802}
803
804bool Fcb::v2::UicRailTicketData::isValid() const
805{
806 return !m_data.isNull();
807}
808
809#include "moc_fcbticket2.cpp"
KItinerary::BitVectorView
Non-owning bit-level view for working with data that isn't byte-aligned.
Definition bitvectorview.h:21
KItinerary::FcbUtil::decodeDifferentialTime
static QDateTime decodeDifferentialTime(const QDateTime &baseDt, int day, std::optional< int > time, std::optional< int > utcOffset)
Decode differential time, relative to baseDt.
Definition fcbutil.cpp:102
KItinerary::FcbUtil::issuingDateTime
static QDateTime issuingDateTime(int year, int day, std::optional< int > time)
Decode FCB issuing time.
Definition fcbutil.cpp:93
KItinerary::FcbUtil::decodeDate
static QDate decodeDate(int year, std::optional< int > day)
Decode FCB date.
Definition fcbutil.cpp:74
KItinerary::Fcb::v2::CarCarriageReservationData
Car carriage reservation document.
Definition fcbticket2.h:572
KItinerary::Fcb::v2::DelayConfirmation
Delay confirmation document.
Definition fcbticket2.h:942
KItinerary::Fcb::v2::DeltaCoordinate
Delta encoding of a geographic coordinate.
Definition fcbticket2.h:79
KItinerary::Fcb::v2::ExtensionData
Generic extension data.
Definition fcbticket2.h:31
KItinerary::Fcb::v2::OpenTicketData
Open ticket document (NRT).
Definition fcbticket2.h:623
KItinerary::Fcb::v2::PassData
Rail pass document (RPT).
Definition fcbticket2.h:702
KItinerary::Fcb::v2::ReservationData
Reservation document (IRT, RES).
Definition fcbticket2.h:498
KItinerary::Fcb::v2::TrainLinkType
Reference to a specific train journey.
Definition fcbticket2.h:189
KItinerary::UPERDecoder
Decoder for data encoded according to X.691 ASN.1 Unaligned Packed Encoding Rules (UPER).
Definition uperdecoder.h:17
KItinerary::UPERDecoder::readSequenceOf
QList< T > readSequenceOf()
Read a sequence-of field with unrestricted size.
Definition uperdecoder.h:76
KItinerary::UPERDecoder::readEnumerated
T readEnumerated()
Read enumerated value.
Definition uperdecoder.h:102
KItinerary::UPERDecoder::readUnconstrainedWholeNumber
int64_t readUnconstrainedWholeNumber()
Read unconstrained whole number.
Definition uperdecoder.cpp:39
KItinerary::UPERDecoder::readUtf8String
QString readUtf8String()
Read UTF-8 string.
Definition uperdecoder.cpp:73
KItinerary::UPERDecoder::readChoiceWithExtensionMarker
QVariant readChoiceWithExtensionMarker()
Read a choice value.
Definition uperdecoder.h:122
KItinerary::UPERDecoder::readOctetString
QByteArray readOctetString()
Read unconstrained octet string (8 bit data).
Definition uperdecoder.cpp:114
KItinerary::UPERDecoder::readBoolean
bool readBoolean()
Read boolean value.
Definition uperdecoder.cpp:81
KItinerary::UPERDecoder::hasError
bool hasError() const
Reading at any point encountered an error.
Definition uperdecoder.cpp:200
KItinerary::UPERDecoder::readIA5String
QByteArray readIA5String()
Read an unconstrained IA5String (7 bit ASCII).
Definition uperdecoder.cpp:98
KItinerary::UPERDecoder::readConstrainedWholeNumber
int64_t readConstrainedWholeNumber(int64_t minimum, int64_t maximum)
Read constrained whole number from the current position.
Definition uperdecoder.cpp:29
KItinerary::Uic9183Block::contentSize
int contentSize() const
Returns the size of the content data.
Definition uic9183block.cpp:81
KItinerary::Uic9183Block::isNull
bool isNull() const
Checks if the block is valid or empty/default constructed.
Definition uic9183block.cpp:91
KItinerary::Uic9183Block::content
const char * content() const
Returns the payload data (not including the block header).
Definition uic9183block.cpp:68
status
Q_SCRIPTABLE CaptureState status()
KItinerary::LocationUtil::location
QVariant location(const QVariant &res)
Returns the location of a non-transport reservation.
Definition locationutil.cpp:98
KItinerary
Classes for reservation/travel data models, data extraction and data augmentation.
Definition berelement.h:17
KTimeZone::country
KI18NLOCALEDATA_EXPORT KCountry country(const char *ianaId)
QByteArray::constData
const char * constData() const const
QByteArray::size
qsizetype size() const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2025 The KDE developers.
Generated on Fri Apr 25 2025 11:50:42 by doxygen 1.13.2 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.