Use PerByte::advance_and_extract() to copy byte chunks from the input.

This should be faster than a get()/advance() loop as it uses std::copy() under
the hood. However, it does require upgrading to the latest version of byteme.

Note that we don't do this for strings as we don't have a buffer we can safely
copy the byte chunks into - std::string methods only expose const pointers.

Author: LTLA

CMakeLists.txt

@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.24)
 
 project(rds2cpp
-    VERSION 1.1.0
+    VERSION 1.2.0
     DESCRIPTION "Standalone C++ library for reading RDS files"
     LANGUAGES CXX)
 
@@ -19,7 +19,7 @@ option(RDS2CPP_FETCH_EXTERN "Automatically fetch rds2cpp's external dependencies
 if(RDS2CPP_FETCH_EXTERN)
     add_subdirectory(extern)
 else()
-    find_package(ltla_byteme CONFIG REQUIRED)
+    find_package(ltla_byteme 2.0.1 CONFIG REQUIRED)
 endif()
 
 target_link_libraries(rds2cpp INTERFACE ltla::byteme)

cmake/Config.cmake.in

@@ -1,6 +1,6 @@
 @PACKAGE_INIT@
 
 include(CMakeFindDependencyMacro)
-find_dependency(ltla_byteme CONFIG REQUIRED)
+find_dependency(ltla_byteme 2.0.1 CONFIG REQUIRED)
 
 include("${CMAKE_CURRENT_LIST_DIR}/ltla_rds2cppTargets.cmake")

extern/CMakeLists.txt

@@ -5,7 +5,7 @@ include(FetchContent)
 FetchContent_Declare(
   byteme 
   GIT_REPOSITORY https://github.com/LTLA/byteme
-  GIT_TAG master
+  GIT_TAG master # ^2.0.1
 )
 
 FetchContent_MakeAvailable(byteme)

include/rds2cpp/parse_atomic.hpp

@@ -21,14 +21,8 @@ Vector parse_integer_or_logical_body(Source_& src) {
     constexpr size_t width = 4;
     static_assert(width == sizeof(decltype(output.data[0])));
     size_t byte_length = width * len;
-
     auto ptr = reinterpret_cast<unsigned char*>(output.data.data());
-    for (size_t i = 0; i < byte_length; ++i) {
-        if (!src.advance()) {
-            throw empty_error();
-        }
-        ptr[i] = src.get();
-    }
+    quick_extract(src, byte_length, ptr);
 
     // Flipping endianness.
     if (little_endian()) {
@@ -65,14 +59,8 @@ DoubleVector parse_double_body(Source_& src) try {
     constexpr size_t width = 8;
     static_assert(width == sizeof(decltype(output.data[0])));
     size_t byte_length = width * len;
-
     auto ptr = reinterpret_cast<unsigned char*>(output.data.data());
-    for (size_t i = 0; i < byte_length; ++i) {
-        if (!src.advance()) {
-            throw empty_error();
-        }
-        ptr[i] = src.get();
-    }
+    quick_extract(src, byte_length, ptr);
 
     // Flipping endianness.
     if (little_endian()) {
@@ -93,12 +81,7 @@ RawVector parse_raw_body(Source_& src) try {
     RawVector output(len);
 
     auto ptr = reinterpret_cast<unsigned char*>(output.data.data());
-    for (size_t i = 0; i < len; ++i) {
-        if (!src.advance()) {
-            throw empty_error();
-        }
-        ptr[i] = src.get();
-    } 
+    quick_extract(src, len, ptr);
 
     return output;
 } catch (std::exception& e) {
@@ -113,14 +96,8 @@ ComplexVector parse_complex_body(Source_& src) try {
     constexpr size_t width = 16;
     static_assert(width == sizeof(decltype(output.data[0])));
     size_t byte_length = width * len;
-
     auto ptr = reinterpret_cast<unsigned char*>(output.data.data());
-    for (size_t b = 0; b < byte_length; ++b) {
-        if (!src.advance()) {
-            throw empty_error();
-        }
-        ptr[b] = src.get();
-    }
+    quick_extract(src, byte_length, ptr);
 
     // Flipping endianness for each double.
     if (little_endian()) {

include/rds2cpp/parse_builtin.hpp

@@ -14,12 +14,12 @@ BuiltInFunction parse_builtin_body(Source_& src) try {
     size_t len = get_length(src);
 
     BuiltInFunction output;
-    output.name.resize(len);
+    output.name.reserve(len); // don't resize and use extract() on string::data, as that pointer is read-only AFAICT.
     for (size_t i = 0; i < len; ++i) {
         if (!src.advance()) {
             throw empty_error();
         }
-        output.name[i] = src.get();
+        output.name.push_back(as_char(src.get()));
     }
 
     return output;

include/rds2cpp/parse_environment.hpp

@@ -45,12 +45,7 @@ EnvironmentIndex parse_new_environment_body(Source_& src, SharedParseInfo& share
 
     // The next 4 bytes describe the parent environment.
     std::array<unsigned char, 4> parent;
-    for (int i = 0; i < 4; ++i) {
-        if (!src.advance()) {
-            throw empty_error();
-        }
-        parent[i] = src.get();
-    }
+    quick_extract(src, parent.size(), parent.data());
 
     auto lastbit = parent[3];
     if (lastbit == static_cast<unsigned char>(SEXPType::REF)) {

include/rds2cpp/parse_rds.hpp

@@ -99,12 +99,7 @@ RdsFile parse_rds(Reader_& reader, const ParseRdsOptions& options) {
             if (!src.advance()) {
                 throw empty_error();
             }
-            for (int pos = 0; pos < 3; ++pos) {
-                if (!src.advance()) {
-                    throw empty_error();
-                }
-               output.writer_version[pos] = src.get();
-            }
+            quick_extract(src, output.writer_version.size(), output.writer_version.data());
         } catch (std::exception& e) {
             throw traceback("failed to read the writer version number from the RDS preamble", e);
         }
@@ -113,12 +108,7 @@ RdsFile parse_rds(Reader_& reader, const ParseRdsOptions& options) {
             if (!src.advance()) {
                 throw empty_error();
             }
-            for (int pos = 0; pos < 3; ++pos) {
-                if (!src.advance()) {
-                    throw empty_error();
-                }
-                output.reader_version[pos] = src.get();
-            }
+            quick_extract(src, output.reader_version.size(), output.reader_version.data());
         } catch (std::exception& e) {
             throw traceback("failed to read the reader version number from the RDS preamble", e);
         }
@@ -140,12 +130,12 @@ RdsFile parse_rds(Reader_& reader, const ParseRdsOptions& options) {
         }
 
         try {
-            output.encoding.reserve(encoding_length);
+            output.encoding.reserve(encoding_length); // don't resize and use extract() on string::data, as that pointer is read-only AFAICT.
             for (size_t b = 0; b < encoding_length; ++b) {
                 if (!src.advance()) {
                     throw empty_error();
                 }
-                output.encoding.push_back(src.get());
+                output.encoding.push_back(as_char(src.get()));
             }
         } catch (std::exception& e) {
             throw traceback("failed to read the encoding string from the RDS preamble", e);

include/rds2cpp/parse_single_string.hpp

@@ -37,13 +37,12 @@ StringInfo parse_single_string(Source_& src) try {
     output.missing = (strlen == static_cast<uint32_t>(-1));
 
     if (!output.missing) {
-        auto& str = output.value;
-        str.resize(strlen);
+        output.value.reserve(strlen); // don't resize and use extract() on string::data, as that pointer is read-only AFAICT.
         for (size_t i = 0; i < strlen; ++i) {
             if (!src.advance()) {
                 throw empty_error();
             }
-            str[i] = src.get();
+            output.value.push_back(as_char(src.get()));
         }
 
         /* String encoding is stored in the gp field, from bits 12 to 27 in the header.

include/rds2cpp/utils_parse.hpp

@@ -16,6 +16,18 @@ inline std::runtime_error empty_error() {
     return std::runtime_error("no more bytes to read");
 }
 
+template<class Source_>
+void quick_extract(Source_& src, size_t len, unsigned char* output) {
+    auto extracted = src.advance_and_extract(len, output);
+    if (extracted != len) {
+        throw empty_error();
+    }
+}
+
+inline char as_char(unsigned char val) {
+    return *reinterpret_cast<const char*>(&val); // make sure we interpret this as a char.
+}
+
 template<class Source_>
 size_t get_length(Source_& src) {
     uint32_t initial = 0;
@@ -63,13 +75,7 @@ typedef std::array<unsigned char, 4> Header;
 template<class Source_>
 Header parse_header(Source_& src) try {
     Header details;
-    int i = 0;
-    for (int b = 0; b < 4; ++b, ++i) {
-        if (!src.advance()) {
-            throw empty_error();
-        }
-        details[i] = src.get();
-    }
+    quick_extract(src, details.size(), details.data());
     return details;
 } catch (std::exception& e) {
     throw traceback("failed to parse the R object header", e);