ticket-decoder 0.19__tar.gz → 0.19.1__tar.gz

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ticket-decoder
-Version: 0.19
+Version: 0.19.1
 Summary: Train ticket barcode to json decoding library, using zxing-cpp decoding in combination with record interpreter, to transform content into json structure
 Keywords: train-ticket,barcode,aztec-code,uic918,vdv,sbb,oebb
 Author: user4223

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/README.md

@@ -42,7 +42,10 @@ For more details about usage see here: [README](./source/python/README.md)
 Prefer using the official module, but when you want to build the module locally,
 the following steps should work:
 ```
-uv build
+export CMAKE_POLICY_VERSION_MINIMUM=3.5         # To make easyloggingcpp building properly using a quite old minimum cmake version
+
+uv build --wheel
+uv venv
 uv pip install dist/ticket_decoder*.whl
 uv run python
 ...

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/pyproject.toml

@@ -3,7 +3,7 @@
 
 [project]
 name = "ticket-decoder"
-version = "v0.19"
+version = "v0.19.1"
 description = "Train ticket barcode to json decoding library, using zxing-cpp decoding in combination with record interpreter, to transform content into json structure"
 license = "GPL-3.0-or-later"
 authors = [ { name = "user4223" } ]

ticket_decoder-0.19.1/source/lib/interpreter/detail/common/include/NumberDecoder.h

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: (C) 2022 user4223 and (other) contributors to ticket-decoder <https://github.com/user4223/ticket-decoder>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <cstdint>
+#include <span>
+#include <string>
+
+namespace interpreter::detail::common
+{
+  class Context;
+
+  class NumberDecoder
+  {
+  public:
+    static std::uint32_t decodeUInteger(std::string_view source);
+
+    /* Decode a signed integer from maximum 8 bytes (or less) big-endian buffer to system byte order.
+       Input can have 1 to 8 bytes but not more.
+       Output will be always a signed integer of 8 bytes.
+     */
+    static std::int64_t decodeSInteger(std::span<std::uint8_t const> source);
+
+    /* Consumes 4 bytes and converts from big-endian to system byte order.
+       Input must be at least of size 4 but can be larger.
+     */
+    static std::uint32_t consumeUInteger4(Context &context);
+    static std::string consumeUInteger4AsString(Context &context);
+    static std::uint32_t decodeUInteger4(std::span<std::uint8_t const> source);
+
+    /* Consumes 3 bytes and converts from big-endian to system byte order.
+       Input must be at least of size 3 but can be larger.
+     */
+    static std::uint32_t consumeUInteger3(Context &context);
+    static std::string consumeUInteger3AsString(Context &context);
+    static std::uint32_t decodeUInteger3(std::span<std::uint8_t const> source);
+
+    /* Consumes 2 bytes and converts from big-endian to system byte order.
+       Input must be at least of size 2 but can be larger.
+     */
+    static std::uint16_t consumeUInteger2(Context &context);
+    static std::string consumeUInteger2AsString(Context &context);
+    static std::uint16_t decodeUInteger2(std::span<std::uint8_t const> source);
+
+    /* Consumes 1 byte.
+       Input must be at least of size 1 but can be larger.
+     */
+    static std::uint8_t consumeUInteger1(Context &context);
+    static std::string consumeUInteger1AsString(Context &context);
+    static std::uint8_t decodeUInteger1(std::span<std::uint8_t const> source);
+  };
+}

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/source/lib/interpreter/detail/common/include/StringDecoder.h

@@ -55,10 +55,11 @@ namespace interpreter::detail::common
         template <typename T>
         static std::string toHexString(T const &bytes)
         {
+            static_assert(std::is_integral_v<T>, "Integral types are supported only");
+            static_assert(std::endian::native == std::endian::little, "Little endian architectures are supported only");
+
             auto const raw = std::span<std::uint8_t const>((std::uint8_t const *const)&bytes, sizeof(T));
-            return std::endian::native == std::endian::big
-                       ? toHexString(raw)
-                       : toHexString(std::vector<std::uint8_t>(raw.rbegin(), raw.rend()));
+            return toHexString(std::vector<std::uint8_t>(raw.rbegin(), raw.rend()));
         }
     };
 }

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/source/lib/interpreter/detail/common/source/DateTimeDecoder.cpp

@@ -15,8 +15,8 @@ namespace interpreter::detail::common
 
     std::string DateTimeDecoder::consumeDateTimeCompact4(Context &context)
     {
-        auto const date = NumberDecoder::consumeInteger2(context);
-        auto const time = NumberDecoder::consumeInteger2(context);
+        auto const date = NumberDecoder::consumeUInteger2(context);
+        auto const time = NumberDecoder::consumeUInteger2(context);
 
         if (date == 0 && time == 0)
         {

ticket_decoder-0.19.1/source/lib/interpreter/detail/common/source/NumberDecoder.cpp

@@ -0,0 +1,164 @@
+// SPDX-FileCopyrightText: (C) 2022 user4223 and (other) contributors to ticket-decoder <https://github.com/user4223/ticket-decoder>
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "../include/NumberDecoder.h"
+
+#include "lib/interpreter/detail/common/include/StringDecoder.h"
+#include "lib/interpreter/detail/common/include/Context.h"
+
+#include <algorithm>
+#include <bit>
+#include <span>
+#include <charconv>
+#include <type_traits>
+
+namespace interpreter::detail::common
+{
+  template <typename T>
+  T getUnsignedAtLeast(std::span<std::uint8_t const> input, std::size_t length = sizeof(T))
+  {
+    static_assert(std::is_integral_v<T>, "Integral types are supported only");
+    static_assert(std::is_unsigned_v<T>, "Unsigned types are supported only");
+    static_assert(std::endian::native == std::endian::little, "Little endian architectures are supported only");
+
+    if (input.size() < length)
+    {
+      throw std::runtime_error(std::string("Less than expected bytes available, expecting at least: ") + std::to_string(length));
+    }
+
+    auto target = T(0);
+    auto destination = std::span<std::uint8_t>(reinterpret_cast<std::uint8_t *>(&target), sizeof(T));
+    auto const source = input.subspan(0, length);
+
+    // if constexpr (std::endian::native == std::endian::big)
+    // {
+    //   auto const offset = sizeof(T) - input.size();
+    //   std::copy(std::begin(input), std::end(input), std::begin(destination) + offset);
+    // }
+    // else
+    {
+      std::copy(std::rbegin(source), std::rend(source), std::begin(destination));
+    }
+
+    return target;
+  }
+
+  template <typename T>
+  T consumeUnsigned(Context &context, std::size_t sourceLength = sizeof(T))
+  {
+    if (sizeof(T) < sourceLength)
+    {
+      throw std::runtime_error("Destination size must be equal or greater than source size");
+    }
+
+    return getUnsignedAtLeast<T>(context.consumeBytes(sourceLength), sourceLength);
+  }
+
+  template <typename T>
+  T getSignedAtMost(std::span<std::uint8_t const> input)
+  {
+    static_assert(std::is_integral_v<T>, "Integral types are supported only");
+    static_assert(std::is_signed_v<T>, "Signed types are supported only");
+    static_assert(std::endian::native == std::endian::little, "Little endian architectures are supported only");
+
+    if (input.size() > sizeof(T))
+    {
+      throw std::runtime_error(std::string("More bytes available than expected, expecting at most: ") + std::to_string(sizeof(T)));
+    }
+    else if (input.empty())
+    {
+      throw std::runtime_error("No bytes available to decode");
+    }
+
+    auto const fillByte = std::uint8_t(input[0] & 0x80 ? 0xff : 0x00);
+    auto const offset = sizeof(T) - input.size();
+
+    auto target = T(0);
+    auto destination = std::span<std::uint8_t>(reinterpret_cast<std::uint8_t *>(&target), sizeof(T));
+
+    // if constexpr (std::endian::native == std::endian::big)
+    // {
+    //   std::fill_n(std::begin(destination) + input.size(), offset, signByte);
+    //   std::copy(std::begin(input), std::end(input), std::begin(destination) + offset);
+    // }
+    // else
+    {
+      std::fill_n(std::begin(destination) + input.size(), offset, fillByte);
+      std::copy(std::rbegin(input), std::rend(input), std::begin(destination));
+    }
+
+    return target;
+  }
+
+  std::uint32_t NumberDecoder::decodeUInteger(std::string_view source)
+  {
+    auto value = std::uint32_t(0);
+    std::from_chars(std::begin(source), std::end(source), value);
+    return value;
+  }
+
+  std::int64_t NumberDecoder::decodeSInteger(std::span<std::uint8_t const> source)
+  {
+    return getSignedAtMost<std::int64_t>(source);
+  }
+
+  std::uint32_t NumberDecoder::consumeUInteger4(Context &context)
+  {
+    return consumeUnsigned<std::uint32_t>(context);
+  }
+
+  std::string NumberDecoder::consumeUInteger4AsString(Context &context)
+  {
+    return std::to_string(consumeUInteger4(context));
+  }
+
+  std::uint32_t NumberDecoder::decodeUInteger4(std::span<std::uint8_t const> source)
+  {
+    return getUnsignedAtLeast<std::uint32_t>(source);
+  }
+
+  std::uint32_t NumberDecoder::consumeUInteger3(Context &context)
+  {
+    return consumeUnsigned<std::uint32_t>(context, 3);
+  }
+
+  std::string NumberDecoder::consumeUInteger3AsString(Context &context)
+  {
+    return std::to_string(consumeUInteger3(context));
+  }
+
+  std::uint32_t NumberDecoder::decodeUInteger3(std::span<std::uint8_t const> source)
+  {
+    return getUnsignedAtLeast<std::uint32_t>(source, 3);
+  }
+
+  std::uint16_t NumberDecoder::consumeUInteger2(Context &context)
+  {
+    return consumeUnsigned<std::uint16_t>(context);
+  }
+
+  std::string NumberDecoder::consumeUInteger2AsString(Context &context)
+  {
+    return std::to_string(consumeUInteger2(context));
+  }
+
+  std::uint16_t NumberDecoder::decodeUInteger2(std::span<std::uint8_t const> source)
+  {
+    return getUnsignedAtLeast<std::uint16_t>(source);
+  }
+
+  std::uint8_t NumberDecoder::consumeUInteger1(Context &context)
+  {
+    return context.consumeByte();
+  }
+
+  std::string NumberDecoder::consumeUInteger1AsString(Context &context)
+  {
+    return std::to_string(consumeUInteger1(context));
+  }
+
+  std::uint8_t NumberDecoder::decodeUInteger1(std::span<std::uint8_t const> source)
+  {
+    return getUnsignedAtLeast<std::uint8_t>(source);
+  }
+}

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/source/lib/interpreter/detail/common/source/TLVDecoder.cpp

@@ -93,6 +93,8 @@ namespace interpreter::detail::common
 
     std::size_t TLVDecoder::consumeLength(common::Context &context)
     {
+        static_assert(std::endian::native == std::endian::little, "Little endian architectures are supported only");
+
         auto const first = context.consumeByte();
         if (first < 0x80)
         {
@@ -109,13 +111,13 @@ namespace interpreter::detail::common
         auto const source = context.consumeBytes(length);
         auto result = std::size_t(0);
         auto const destination = std::span<std::uint8_t>(reinterpret_cast<std::uint8_t *>(&result), maxSize);
-        if constexpr (std::endian::native == std::endian::little)
-        {
-            std::copy(source.rbegin(), source.rend(), destination.begin());
-        }
-        else
+        // if constexpr (std::endian::native == std::endian::big)
+        // {
+        //     std::copy(source.begin(), source.end(), destination.begin() + maxSize - length);
+        // }
+        // else
         {
-            std::copy(source.begin(), source.end(), destination.begin() + maxSize - length);
+            std::copy(std::rbegin(source), std::rend(source), std::begin(destination));
         }
         return result;
     }

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/source/lib/interpreter/detail/misc/source/CSVInterpreter.cpp

@@ -52,10 +52,10 @@ namespace interpreter::detail::misc
         if (parts.size() == 16)
         {
             recordJson
-                .add("price", common::NumberDecoder::decodeInteger(parts[3]))
+                .add("price", common::NumberDecoder::decodeUInteger(parts[3]))
                 .add("validFromDate", common::DateTimeDecoder::decodeASCIIDate6(parts[5]))
                 .add("validUntilDate", common::DateTimeDecoder::decodeASCIIDate6(parts[6]))
-                .add("passengerNumber", common::NumberDecoder::decodeInteger(parts[7])) // maybe
+                .add("passengerNumber", common::NumberDecoder::decodeUInteger(parts[7])) // maybe
                 .add("ticketId", parts[8])                                              // maybe
                 .add("issuingDate", common::DateTimeDecoder::decodeASCIIDate6(parts[11]))
                 .add("fromStationIBNR", parts[12])

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/source/lib/interpreter/detail/uic918/source/Record0080VU.cpp

@@ -27,16 +27,16 @@ namespace interpreter::detail::uic
   {
     auto recordJson = ::utility::JsonBuilder::object(); // clang-format off
     recordJson
-      .add("terminalNummer", NumberDecoder::consumeInteger2AsString(context))
-      .add("samNummer", NumberDecoder::consumeInteger3AsString(context))
-      .add("anzahlPersonen", NumberDecoder::consumeInteger1AsString(context))
-      .add("efs", ::utility::toArray(NumberDecoder::consumeInteger1(context), [&context](auto &builder)
+      .add("terminalNummer", NumberDecoder::consumeUInteger2AsString(context))
+      .add("samNummer", NumberDecoder::consumeUInteger3AsString(context))
+      .add("anzahlPersonen", NumberDecoder::consumeUInteger1AsString(context))
+      .add("efs", ::utility::toArray(NumberDecoder::consumeUInteger1(context), [&context](auto &builder)
         { 
           // TODO Unsure if numeric is the proper interpretation of berechtigungsNummer
-          auto const berechtigungsNummer = NumberDecoder::consumeInteger4(context);
-          auto const kvpOrganisationsId = NumberDecoder::consumeInteger2(context);
-          auto const pvProduktnummer = NumberDecoder::consumeInteger2(context);
-          auto const pvOrganisationsId = NumberDecoder::consumeInteger2(context);
+          auto const berechtigungsNummer = NumberDecoder::consumeUInteger4(context);
+          auto const kvpOrganisationsId = NumberDecoder::consumeUInteger2(context);
+          auto const pvProduktnummer = NumberDecoder::consumeUInteger2(context);
+          auto const pvOrganisationsId = NumberDecoder::consumeUInteger2(context);
           auto const pvProduktbezeichnung = getProduktbezeichnung(pvOrganisationsId, pvProduktnummer);
 
           builder
@@ -49,25 +49,25 @@ namespace interpreter::detail::uic
             .add("pvOrganisationsId", std::to_string(pvOrganisationsId))
             .add("gueltigAb", DateTimeDecoder::consumeDateTimeCompact4(context))
             .add("gueltigBis", DateTimeDecoder::consumeDateTimeCompact4(context))
-            .add("preis", NumberDecoder::consumeInteger3(context))
-            .add("samSequenznummer", NumberDecoder::consumeInteger4AsString(context))
-            .add("flaechenelemente", ::utility::toDynamicArray(NumberDecoder::consumeInteger1(context), [&context](auto &builder)
+            .add("preis", NumberDecoder::consumeUInteger3(context))
+            .add("samSequenznummer", NumberDecoder::consumeUInteger4AsString(context))
+            .add("flaechenelemente", ::utility::toDynamicArray(NumberDecoder::consumeUInteger1(context), [&context](auto &builder)
               {
                 auto tagStream = std::ostringstream();
-                auto const tagValue = int(NumberDecoder::consumeInteger1(context));
+                auto const tagValue = int(NumberDecoder::consumeUInteger1(context));
                 tagStream << std::hex << std::noshowbase << tagValue;
                 auto const tag = tagStream.str();
-                auto const elementLength = NumberDecoder::consumeInteger1(context);
-                auto const typ = NumberDecoder::consumeInteger1AsString(context);
-                auto const organisationsId = NumberDecoder::consumeInteger2AsString(context);
+                auto const elementLength = NumberDecoder::consumeUInteger1(context);
+                auto const typ = NumberDecoder::consumeUInteger1AsString(context);
+                auto const organisationsId = NumberDecoder::consumeUInteger2AsString(context);
                 auto const flaechenIdLength = elementLength - 3;
                 if (flaechenIdLength != 2 && flaechenIdLength != 3)
                 {
                   throw std::runtime_error(std::string("Unexpected FlaechenelementId length: ") + std::to_string(flaechenIdLength)); 
                 }
                 auto const flaechenId = std::to_string(flaechenIdLength == 2
-                  ? NumberDecoder::consumeInteger2(context)
-                  : NumberDecoder::consumeInteger3(context));
+                  ? NumberDecoder::consumeUInteger2(context)
+                  : NumberDecoder::consumeUInteger3(context));
 
                 builder
                   .add("tag", tag)

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/source/lib/interpreter/detail/uic918/u_flex/include/UflexUtility.h

@@ -16,6 +16,12 @@ namespace interpreter::detail::uic::u_flex
   TICKET_DECODER_EXPORT
   std::optional<std::string> daysAndYearToIsoDate(long const *const year, long const *const dayOfYear);
 
+  TICKET_DECODER_EXPORT
+  std::optional<std::string> dayMonthYearToIsoDate(long const year, long const month, long const dayOfMonth);
+
+  TICKET_DECODER_EXPORT
+  std::optional<std::string> dayMonthYearToIsoDate(long const *const year, long const *const month, long const *const dayOfMonth);
+
   TICKET_DECODER_EXPORT
   std::optional<std::string> minutesToIsoTime(long const noOfMinutes);
 

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/source/lib/interpreter/detail/uic918/u_flex/source/UflexUtility.cpp

@@ -58,7 +58,7 @@ namespace interpreter::detail::uic::u_flex
 
     unsigned int dayOfMonth = dayOfYear - *smaller;
 
-    std::stringstream os;
+    auto os = std::stringstream();
     os << year << "-"
        << std::setw(2) << std::setfill('0') << month << "-"
        << std::setw(2) << std::setfill('0') << dayOfMonth;
@@ -75,6 +75,25 @@ namespace interpreter::detail::uic::u_flex
     return daysAndYearToIsoDate(*year, *dayOfYear);
   }
 
+  std::optional<std::string> dayMonthYearToIsoDate(long const year, long const month, long const dayOfMonth)
+  {
+    auto os = std::stringstream();
+    os << year << "-"
+       << std::setw(2) << std::setfill('0') << month << "-"
+       << std::setw(2) << std::setfill('0') << dayOfMonth;
+    return os.str();
+  }
+
+  std::optional<std::string> dayMonthYearToIsoDate(long const *const year, long const *const month, long const *const dayOfMonth)
+  {
+    if (year == nullptr || month == nullptr || dayOfMonth == nullptr)
+    {
+      return std::nullopt;
+    }
+
+    return dayMonthYearToIsoDate(*year, *month, *dayOfMonth);
+  }
+
   std::optional<std::string> minutesToIsoTime(long const noOfMinutes)
   {
 
@@ -99,7 +118,7 @@ namespace interpreter::detail::uic::u_flex
       hours = hours - days * 24l;
     }
 
-    std::stringstream os;
+    auto os = std::stringstream();
     os << std::setw(2) << std::setfill('0') << hours << ":"
        << std::setw(2) << std::setfill('0') << minutes << ":"
        << "00";
@@ -127,7 +146,7 @@ namespace interpreter::detail::uic::u_flex
     auto const hours = noOfMinutes / 60l;
     auto const minutes = noOfMinutes - hours * 60l;
 
-    std::stringstream os;
+    auto os = std::stringstream();
     os << std::setw(3) << std::setfill('0') << std::internal << std::showpos << hours << ":"
        << std::setw(2) << std::setfill('0') << std::internal << std::noshowpos << minutes;
     return os.str();

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/source/lib/interpreter/detail/uic918/u_flex/v1.3/CMakeLists.txt

@@ -20,4 +20,5 @@ target_link_libraries(${PROJECT_NAME} PRIVATE
    nlohmann_json::nlohmann_json
    easyloggingpp::easyloggingpp
    ticket-decoder-utility
-   ticket-decoder-infrastructure)
+   ticket-decoder-infrastructure
+   ticket-decoder-interpreter-detail-common)

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/source/lib/interpreter/detail/uic918/u_flex/v1.3/source/RecordU_FLEX_13.cpp

@@ -5,6 +5,9 @@
 
 #include "lib/infrastructure/include/Logging.h"
 
+#include "lib/interpreter/detail/common/include/NumberDecoder.h"
+#include "lib/interpreter/detail/common/include/StringDecoder.h"
+
 #include "../../include/UflexUtility.h"
 #include "../../include/JsonSupport.h"
 
@@ -12,6 +15,8 @@
 
 namespace utility
 {
+  using namespace interpreter::detail::common;
+
   /* Explicit specializations for some ASN1 specific types */
 
   template <>
@@ -21,22 +26,19 @@ namespace utility
     {
       return *this;
     }
-    return add(std::string((char *)field->buf, (std::size_t)field->size));
+    return add(StringDecoder::decodeUTF8(std::span<uint8_t const>(field->buf, field->size)));
   }
 
   template <>
   JsonBuilder &JsonBuilder::add(std::string name, UTF8String_t const &field)
   {
-    return add(name, std::string((char *)field.buf, (std::size_t)field.size));
+    return add(name, StringDecoder::decodeUTF8(std::span<uint8_t const>(field.buf, field.size)));
   }
 
   template <>
   JsonBuilder &JsonBuilder::add(std::string name, INTEGER_t const &field)
   {
-    long value = 0;
-    auto end = (char const *)(field.buf + field.size);
-    ::asn_strtol_lim((char const *)field.buf, &end, &value);
-    return add(name, value);
+    return add(name, NumberDecoder::decodeSInteger(std::span<std::uint8_t const>(field.buf, field.size)));
   }
 
   template <>
@@ -46,10 +48,7 @@ namespace utility
     {
       return *this;
     }
-    long value = 0;
-    auto end = (char const *)(field->buf + field->size);
-    ::asn_strtol_lim((char const *)field->buf, &end, &value);
-    return add(name, value);
+    return add(name, *field);
   }
 
   static std::optional<std::string> toString(ENUMERATED_t *const source)

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/source/lib/interpreter/detail/uic918/u_flex/v3.0/CMakeLists.txt

@@ -20,4 +20,5 @@ target_link_libraries(${PROJECT_NAME} PRIVATE
    nlohmann_json::nlohmann_json
    easyloggingpp::easyloggingpp
    ticket-decoder-utility
-   ticket-decoder-infrastructure)
+   ticket-decoder-infrastructure
+   ticket-decoder-interpreter-detail-common)

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/source/lib/interpreter/detail/uic918/u_flex/v3.0/source/RecordU_FLEX_30.cpp

@@ -5,6 +5,9 @@
 
 #include "lib/infrastructure/include/Logging.h"
 
+#include "lib/interpreter/detail/common/include/NumberDecoder.h"
+#include "lib/interpreter/detail/common/include/StringDecoder.h"
+
 #include "../../include/UflexUtility.h"
 #include "../../include/JsonSupport.h"
 
@@ -12,6 +15,8 @@
 
 namespace utility
 {
+  using namespace interpreter::detail::common;
+
   /* Explicit specializations for some ASN1 specific types */
 
   template <>
@@ -21,22 +26,19 @@ namespace utility
     {
       return *this;
     }
-    return add(std::string((char *)field->buf, (std::size_t)field->size));
+    return add(StringDecoder::decodeUTF8(std::span<std::uint8_t const>(field->buf, field->size)));
   }
 
   template <>
   JsonBuilder &JsonBuilder::add(std::string name, UTF8String_t const &field)
   {
-    return add(name, std::string((char *)field.buf, (std::size_t)field.size));
+    return add(name, StringDecoder::decodeUTF8(std::span<std::uint8_t const>(field.buf, field.size)));
   }
 
   template <>
   JsonBuilder &JsonBuilder::add(std::string name, INTEGER_t const &field)
   {
-    long value = 0;
-    auto end = (char const *)(field.buf + field.size);
-    ::asn_strtol_lim((char const *)field.buf, &end, &value);
-    return add(name, value);
+    return add(name, NumberDecoder::decodeSInteger(std::span<std::uint8_t const>(field.buf, field.size)));
   }
 
   template <>
@@ -46,10 +48,7 @@ namespace utility
     {
       return *this;
     }
-    long value = 0;
-    auto end = (char const *)(field->buf + field->size);
-    ::asn_strtol_lim((char const *)field->buf, &end, &value);
-    return add(name, value);
+    return add(name, *field);
   }
 
   static std::optional<std::string> toString(ENUMERATED_t *const source)
@@ -117,7 +116,7 @@ namespace interpreter::detail::uic::u_flex30
                   .add("gender", ::utility::toString(traveler.gender))
                   .add("customerId", traveler.customerIdIA5)
                   .add("customerIdNum", traveler.customerIdNum)
-                  .add("dateOfBirth", u_flex::daysAndYearToIsoDate(traveler.yearOfBirth, traveler.dayOfBirthInMonth))
+                  .add("dateOfBirth", u_flex::dayMonthYearToIsoDate(traveler.yearOfBirth, traveler.monthOfBirth, traveler.dayOfBirthInMonth))
                   .add("ticketHolder", traveler.ticketHolder)
                   .add("passengerType", ::utility::toString(traveler.passengerType))
                   .add("passengerWithReducedMobility", traveler.passengerWithReducedMobility)
@@ -259,7 +258,7 @@ namespace interpreter::detail::uic::u_flex30
                       .add("gender", ::utility::toString(customer.gender))
                       .add("customerId", customer.customerIdIA5)
                       .add("customerIdNum", customer.customerIdNum)
-                      .add("dateOfBirth", u_flex::daysAndYearToIsoDate(customer.yearOfBirth, customer.dayOfBirthInMonth))
+                      .add("dateOfBirth", u_flex::dayMonthYearToIsoDate(customer.yearOfBirth, customer.monthOfBirth, customer.dayOfBirthInMonth))
                       .add("ticketHolder", customer.ticketHolder)
                       .add("passengerType", ::utility::toString(customer.passengerType))
                       .add("passengerWithReducedMobility", customer.passengerWithReducedMobility)

{ticket_decoder-0.19 → ticket_decoder-0.19.1}/source/lib/interpreter/detail/vdv/source/Certificate.cpp

@@ -73,7 +73,7 @@ namespace interpreter::detail::vdv
     auto context = Context(inputContext.consumeBytes(length));
     auto parts = std::vector<std::uint32_t>{};
 
-    auto const header = NumberDecoder::consumeInteger1(context);
+    auto const header = NumberDecoder::consumeUInteger1(context);
     if (header < 40) // ITU-T
     {
       parts.insert(parts.begin(), {0, header});
@@ -91,7 +91,7 @@ namespace interpreter::detail::vdv
     {
       auto part = std::uint32_t{0};
       auto chunk = std::uint32_t{0}; //            MSB = 1 means more bytes
-      for (chunk = NumberDecoder::consumeInteger1(context); chunk & 0x80; chunk = NumberDecoder::consumeInteger1(context))
+      for (chunk = NumberDecoder::consumeUInteger1(context); chunk & 0x80; chunk = NumberDecoder::consumeUInteger1(context))
       {
         part = (part | (chunk & 0x7f)) << 7; // Drop MSB, OR it to what we have already and shift left to ensure space 4 next chunk
       }
@@ -114,9 +114,9 @@ namespace interpreter::detail::vdv
   {
     auto region = StringDecoder::decodeLatin1(context.consumeBytes(2));
     auto name = StringDecoder::decodeLatin1(context.consumeBytes(3));
-    auto serviceIdenticator = NumberDecoder::consumeInteger1(context);
-    auto algorithmReference = NumberDecoder::consumeInteger1(context);
-    auto year = std::to_string(1990 + NumberDecoder::consumeInteger1(context));
+    auto serviceIdenticator = NumberDecoder::consumeUInteger1(context);
+    auto algorithmReference = NumberDecoder::consumeUInteger1(context);
+    auto year = std::to_string(1990 + NumberDecoder::consumeUInteger1(context));
     return CertificateParticipant{std::move(region), std::move(name), serviceIdenticator, algorithmReference, std::move(year)};
   }
 
@@ -144,11 +144,11 @@ namespace interpreter::detail::vdv
 
   CertificateReference CertificateReference::consumeFrom(common::Context &context)
   {
-    auto orgId = NumberDecoder::consumeInteger2AsString(context);
+    auto orgId = NumberDecoder::consumeUInteger2AsString(context);
     auto samValidUntil = CertificateDate::consumeFrom2(context);
     auto samValidFrom = CertificateDate::consumeFrom3(context);
-    auto ownerOrgId = NumberDecoder::consumeInteger2AsString(context);
-    auto samId = NumberDecoder::consumeInteger3AsString(context);
+    auto ownerOrgId = NumberDecoder::consumeUInteger2AsString(context);
+    auto samId = NumberDecoder::consumeUInteger3AsString(context);
     return CertificateReference{std::move(orgId), std::move(samValidUntil), std::move(samValidFrom), std::move(ownerOrgId), std::move(samId)};
   }
 
@@ -195,7 +195,7 @@ namespace interpreter::detail::vdv
   CertificateAuthorization CertificateAuthorization::consumeFrom(common::Context &context)
   {
     auto name = StringDecoder::consumeUTF8(context, 6);
-    auto const serviceIndicator = NumberDecoder::consumeInteger1(context);
+    auto const serviceIndicator = NumberDecoder::consumeUInteger1(context);
     return CertificateAuthorization{std::move(name), serviceIndicator};
   }
 
@@ -206,7 +206,7 @@ namespace interpreter::detail::vdv
 
   CertificateProfile CertificateProfile::consumeFrom(common::Context &context)
   {
-    auto identifier = NumberDecoder::consumeInteger1AsString(context);
+    auto identifier = NumberDecoder::consumeUInteger1AsString(context);
     return CertificateProfile{std::move(identifier)};
   }