components/core/src/clp/streaming_archive/reader/Segment.cpp (2)

Line range hint 46-56: Enhance error handling with specific failure details

Consider capturing and logging the specific reason for memory mapping failure to aid in debugging.

     m_memory_mapped_segment_file.emplace(segment_path);
     if (false == m_memory_mapped_segment_file.has_value()) {
         SPDLOG_ERROR(
-                "streaming_archive::reader:Segment: Unable to memory map the compressed "
-                "segment with path: {}",
-                segment_path.c_str()
+                "streaming_archive::reader:Segment: Unable to memory map the compressed "
+                "segment with path: {} (errno: {}, message: {})",
+                segment_path.c_str(),
+                errno,
+                std::strerror(errno)
         );
         return ErrorCode_Failure;
     }

---

Replace boost::filesystem with std::filesystem in multiple files

The verification shows extensive usage of boost::filesystem across the codebase, particularly in:

• File operations (exists, file_size, remove)
• Path manipulations (path, parent_path, weakly_canonical)
• Directory operations (is_directory, create_directory, directory_iterator)

The migration to std::filesystem will require changes in:

• Header includes
• Namespace usage
• Some API adjustments (e.g., boost::filesystem::filesystem_error to std::filesystem::filesystem_error)

🔗 Analysis chain

Line range hint 8-8: Replace boost::filesystem with std::filesystem

Since the PR's objective is to remove boost dependencies, consider replacing boost::filesystem with std::filesystem (available since C++17).

-#include <boost/filesystem.hpp>
+#include <filesystem>

Also update any boost::filesystem namespace usage to std::filesystem.

🏁 Scripts executed

The following scripts were executed for the analysis:

Script:

#!/bin/bash
# Check for remaining boost::filesystem usage
rg "boost::filesystem" --type cpp

Length of output: 14835

components/core/tests/test-StreamingCompression.cpp (3)

4-4: Consider replacing boost::filesystem with std::filesystem

While the PR aims to remove boost dependencies, boost::filesystem is still used for file cleanup operations. Consider using std::filesystem (C++17) instead:

-#include <boost/filesystem.hpp>
+#include <filesystem>

 // ... rest of the file ...

-        boost::filesystem::remove(compressed_file_path);
+        std::filesystem::remove(compressed_file_path);

Also applies to: 232-232

---

Line range hint 19-23: Consider using std::vector for safer memory management

Replace manual memory management with std::vector to prevent potential memory leaks and improve exception safety:

-    char* uncompressed_data = new char[uncompressed_data_size];
-    for (size_t i = 0; i < uncompressed_data_size; ++i) {
-        uncompressed_data[i] = (char)('a' + (i % 26));
-    }
+    std::vector<char> uncompressed_data(uncompressed_data_size);
+    std::generate(uncompressed_data.begin(), uncompressed_data.end(),
+                 [n = 0]() mutable { return (char)('a' + ((n++) % 26)); });

---

Line range hint 1-233: Consider using parameterized tests to reduce code duplication

The test file contains significant repetition in the decompression verification steps. Consider using Catch2's parameterized testing features to reduce duplication:

SCENARIO("StreamingCompression decompression verification") {
    std::vector<size_t> chunk_sizes = {
        uncompressed_data_size / 100,
        uncompressed_data_size / 50,
        uncompressed_data_size / 25,
        // ... other sizes
    };
    
    for (const auto& chunk_size : chunk_sizes) {
        GIVEN("A chunk of size " + std::to_string(chunk_size)) {
            REQUIRE(ErrorCode_Success ==
                    decompressor.get_decompressed_stream_region(
                        uncompressed_bytes,
                        decompressed_data,
                        chunk_size));
            REQUIRE(memcmp(uncompressed_data, decompressed_data, chunk_size) == 0);
            memset(decompressed_data, 0, uncompressed_data_size);
            uncompressed_bytes += chunk_size;
        }
    }
}

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Description: Check for any remaining Boost::iostreams usage in source files

# Search for any remaining boost::iostreams includes or usage
echo "Checking for boost::iostreams includes..."
rg -l "boost.*iostreams" components/core/src/clp/make_dictionaries_readable/

# Search for mapped_file_source specifically
echo "Checking for mapped_file_source usage..."
rg -l "mapped_file_source" components/core/src/clp/make_dictionaries_readable/

#!/bin/bash
# Let's try a more comprehensive search for any Boost I/O related code

# Search for any Boost I/O related patterns with context
echo "=== Searching for Boost I/O patterns ==="
rg -i "boost.*(io|stream|mapped)" components/core/src/clp/make_dictionaries_readable/ -C 2

# Check the implementation files for memory mapping
echo -e "\n=== Checking memory mapping implementation ==="
fd -e cpp -e hpp . components/core/src/clp/make_dictionaries_readable/ --exec cat {}

# Look for any remaining Boost includes
echo -e "\n=== Checking all Boost includes ==="
rg "#include.*boost" components/core/src/clp/make_dictionaries_readable/

#!/bin/bash
# Description: Verify that ReadOnlyMemoryMappedFile provides equivalent functionality to boost::iostreams::mapped_file_source

# Search for the ReadOnlyMemoryMappedFile interface
echo "Searching for ReadOnlyMemoryMappedFile interface..."
rg -t hpp "class.*ReadOnlyMemoryMappedFile"

# Search for usage patterns of the old boost implementation to ensure all cases are covered
echo "Searching for previous boost::iostreams usage patterns..."
rg -B 2 -A 2 "boost::iostreams::mapped_file_source" 

#!/bin/bash
# Search for ReadOnlyMemoryMappedFile implementation and usage
rg -g "*.{cpp,hpp,h}" "ReadOnlyMemoryMappedFile" -B 3 -A 3

# Search for memory mapped file related methods in Segment class
ast-grep --pattern 'class Segment {
  $$$
}'

#!/bin/bash
# Description: Verify memory mapping implementation transition
# Expected: All files should use the new ReadOnlyMemoryMappedFile class

# Find files that might use memory mapping
rg -l "mapped_file|mmap" components/core/src/clp/clg/

# Check usage of ReadOnlyMemoryMappedFile
ast-grep --pattern 'ReadOnlyMemoryMappedFile'

#!/bin/bash
# Description: Check for any remaining boost/iostreams includes
# Expected: No matches as the dependency has been removed

# Search for boost/iostreams includes
rg -l "boost/iostreams" components/core/src/clp/clg/

# Search for boost::iostreams namespace usage
rg -l "boost::iostreams" components/core/src/clp/clg/

#!/bin/bash
# Let's check for any remaining boost/iostreams includes or usage specifically in the clg directory
rg -l "boost/iostreams|boost::iostreams" components/core/src/clp/clg/

# Also check for any direct usage of mapped_file or mmap in clg directory
rg -l "mapped_file|mmap" components/core/src/clp/clg/

# Let's see how the new ReadOnlyMemoryMappedFile is being used in clg
rg -l "ReadOnlyMemoryMappedFile" components/core/src/clp/clg/

#!/bin/bash
# Description: Check for documentation files that might need updates

# Look for common documentation files
fd -e md -e rst --exec rg -l "boost.*iostreams|dependencies|build requirements"

#!/bin/bash
# Description: Check for indirect Boost::iostreams dependencies

# Search for any remaining boost::iostreams usage
rg -l "boost.*iostreams|boost/iostreams" --type cpp --type hpp

# Check CMake files for indirect Boost dependencies
fd -e cmake -e txt -x rg -l "Boost::iostreams|boost.*iostreams"

#!/bin/bash
# Let's check the content of the CMake files that mention Boost::iostreams
echo "=== components/core/src/glt/glt/CMakeLists.txt ==="
cat components/core/src/glt/glt/CMakeLists.txt

echo -e "\n=== components/core/src/clp_s/CMakeLists.txt ==="
cat components/core/src/clp_s/CMakeLists.txt

echo -e "\n=== components/core/CMakeLists.txt ==="
cat components/core/CMakeLists.txt

# Also check if there are any direct includes of boost/iostreams in the codebase
echo -e "\n=== Checking for direct includes of boost/iostreams ==="
rg "include.*boost/iostreams" --type cpp --type hpp

#!/bin/bash
# Let's check for any direct includes of boost/iostreams with proper file extensions
rg "include.*boost/iostreams" -t cpp -t h -t hpp -t cc

# Also check for any usage of boost::iostreams namespace
rg "boost::iostreams::" -t cpp -t h -t hpp -t cc

#!/bin/bash
# Search for boost/iostreams includes and usage without file type filters
rg "include.*boost/iostreams"

# Search for boost::iostreams namespace usage
rg "boost::iostreams::"

# Also check if there are any files that might be using iostreams indirectly
rg -l "iostream|istream|ostream|filtering_stream|filtering_streambuf"