remove output_stream

Author: Alex-PLACET

CMakeLists.txt

@@ -116,7 +116,6 @@ set(SPARROW_IPC_HEADERS
     ${SPARROW_IPC_INCLUDE_DIR}/sparrow_ipc/magic_values.hpp
     ${SPARROW_IPC_INCLUDE_DIR}/sparrow_ipc/memory_output_stream.hpp
     ${SPARROW_IPC_INCLUDE_DIR}/sparrow_ipc/metadata.hpp
-    ${SPARROW_IPC_INCLUDE_DIR}/sparrow_ipc/output_stream.hpp
     ${SPARROW_IPC_INCLUDE_DIR}/sparrow_ipc/serialize_utils.hpp
     ${SPARROW_IPC_INCLUDE_DIR}/sparrow_ipc/serialize.hpp
     ${SPARROW_IPC_INCLUDE_DIR}/sparrow_ipc/serializer.hpp

include/sparrow_ipc/any_output_stream.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <array>
 #include <concepts>
 #include <cstddef>
 #include <cstdint>
@@ -26,8 +25,8 @@ namespace sparrow_ipc
     /**
      * @brief Type-erased wrapper for any stream-like object.
      *
-     * This class provides type erasure for ANY type that supports stream operations,
-     * not just those derived from output_stream. It uses the concept-based type erasure
+     * This class provides type erasure for ANY type that supports stream operations.
+     * It uses the concept-based type erasure
      * pattern to wrap any stream-like object polymorphically.
      *
      * @details This implementation uses the classic type erasure pattern with:
@@ -37,7 +36,6 @@ namespace sparrow_ipc
      *
      * Usage:
      * @code
-     * // Works with output_stream derived classes
      * std::vector<uint8_t> buffer;
      * memory_output_stream<std::vector<uint8_t>> mem_stream(buffer);
      * any_output_stream stream1(mem_stream);

include/sparrow_ipc/chunk_memory_output_stream.hpp

@@ -1,17 +1,17 @@
 #pragma once
 
 #include <cstdint>
+#include <functional>
 #include <numeric>
 #include <ranges>
-
-#include "sparrow_ipc/output_stream.hpp"
+#include <vector>
 
 namespace sparrow_ipc
 {
     /**
      * @brief An output stream that writes data into separate memory chunks.
      *
-     * This template class implements an output_stream that stores data in discrete memory chunks
+     * This template class stores data in discrete memory chunks
      * rather than a single contiguous buffer. Each write operation creates a new chunk, making it
      * suitable for scenarios where data needs to be processed or transmitted in separate units.
      *
@@ -29,7 +29,7 @@ namespace sparrow_ipc
         requires std::ranges::random_access_range<R>
                  && std::ranges::random_access_range<std::ranges::range_value_t<R>>
                  && std::same_as<typename std::ranges::range_value_t<R>::value_type, uint8_t>
-    class chunked_memory_output_stream final : public output_stream
+    class chunked_memory_output_stream
     {
     public:
 
@@ -51,7 +51,7 @@ namespace sparrow_ipc
          * @param count Number of characters to write
          * @return Reference to this stream for method chaining
          */
-        chunked_memory_output_stream<R>& write(const char* s, std::streamsize count) final;
+        chunked_memory_output_stream<R>& write(const char* s, std::streamsize count);
 
         /**
          * @brief Writes a span of bytes as a new chunk.
@@ -61,7 +61,7 @@ namespace sparrow_ipc
          * @param span A span of bytes to write as a new chunk
          * @return Reference to this stream for method chaining
          */
-        chunked_memory_output_stream<R>& write(std::span<const std::uint8_t> span) final;
+        chunked_memory_output_stream<R>& write(std::span<const std::uint8_t> span);
 
         /**
          * @brief Writes a buffer by moving it into the chunk container.
@@ -83,7 +83,7 @@ namespace sparrow_ipc
          * @param count Number of times to repeat the value
          * @return Reference to this stream for method chaining
          */
-        chunked_memory_output_stream<R>& write(uint8_t value, std::size_t count) final;
+        chunked_memory_output_stream<R>& write(uint8_t value, std::size_t count);
 
         /**
          * @brief Writes a single character as a new chunk.
@@ -93,7 +93,7 @@ namespace sparrow_ipc
          * @param value The character value to write
          * @return Reference to this stream for method chaining
          */
-        chunked_memory_output_stream<R>& put(char value) final;
+        chunked_memory_output_stream<R>& put(char value);
 
         /**
          * @brief Reserves capacity in the chunk container.
@@ -103,7 +103,7 @@ namespace sparrow_ipc
          *
          * @param size Number of chunks to reserve space for
          */
-        void reserve(std::size_t size) override;
+        void reserve(std::size_t size);
 
         /**
          * @brief Reserves capacity using a lazy calculation function.
@@ -112,7 +112,7 @@ namespace sparrow_ipc
          *
          * @param calculate_reserve_size Function that returns the number of chunks to reserve
          */
-        void reserve(const std::function<std::size_t()>& calculate_reserve_size) override;
+        void reserve(const std::function<std::size_t()>& calculate_reserve_size);
 
         /**
          * @brief Gets the total size of all chunks.
@@ -121,7 +121,7 @@ namespace sparrow_ipc
          *
          * @return The total number of bytes across all chunks
          */
-        [[nodiscard]] size_t size() const override;
+        [[nodiscard]] size_t size() const;
 
     private:
 

include/sparrow_ipc/memory_output_stream.hpp

@@ -1,9 +1,8 @@
 
 #include <cstdint>
+#include <functional>
 #include <ranges>
 
-#include "sparrow_ipc/output_stream.hpp"
-
 namespace sparrow_ipc
 {
     /**
@@ -26,7 +25,7 @@ namespace sparrow_ipc
      */
     template <typename R>
         requires std::ranges::random_access_range<R> && std::same_as<typename R::value_type, uint8_t>
-    class memory_output_stream final : public output_stream
+    class memory_output_stream
     {
     public:
 
@@ -52,7 +51,7 @@ namespace sparrow_ipc
          *
          * @note The characters are converted to uint8_t and appended to the buffer
          */
-        memory_output_stream& write(const char* s, std::streamsize count) final;
+        memory_output_stream& write(const char* s, std::streamsize count);
 
         /**
          * @brief Writes a span of bytes to the buffer.
@@ -62,7 +61,7 @@ namespace sparrow_ipc
          * @param span A span of bytes to write
          * @return Reference to this stream for method chaining
          */
-        memory_output_stream& write(std::span<const std::uint8_t> span) final;
+        memory_output_stream& write(std::span<const std::uint8_t> span);
 
         /**
          * @brief Writes a byte value repeated a specified number of times.
@@ -74,7 +73,7 @@ namespace sparrow_ipc
          * @param count Number of times to repeat the value
          * @return Reference to this stream for method chaining
          */
-        memory_output_stream& write(uint8_t value, std::size_t count) final;
+        memory_output_stream& write(uint8_t value, std::size_t count);
 
         /**
          * @brief Writes a single character to the buffer.
@@ -84,7 +83,7 @@ namespace sparrow_ipc
          * @param value The character value to write
          * @return Reference to this stream for method chaining
          */
-        memory_output_stream& put(char value) final;
+        memory_output_stream& put(char value);
 
         /**
          * @brief Reserves capacity in the underlying buffer.
@@ -94,7 +93,7 @@ namespace sparrow_ipc
          *
          * @param size Number of bytes to reserve
          */
-        void reserve(std::size_t size) override;
+        void reserve(std::size_t size);
 
         /**
          * @brief Reserves capacity using a lazy calculation function.
@@ -103,14 +102,14 @@ namespace sparrow_ipc
          *
          * @param calculate_reserve_size Function that returns the number of bytes to reserve
          */
-        void reserve(const std::function<std::size_t()>& calculate_reserve_size) override;
+        void reserve(const std::function<std::size_t()>& calculate_reserve_size);
 
         /**
          * @brief Gets the current size of the buffer.
          *
          * @return The number of bytes currently in the buffer
          */
-        [[nodiscard]] size_t size() const override;
+        [[nodiscard]] size_t size() const;
 
     private:
 

include/sparrow_ipc/output_stream.hpp

@@ -8,7 +8,6 @@
 #include "sparrow_ipc/any_output_stream.hpp"
 #include "sparrow_ipc/config/config.hpp"
 #include "sparrow_ipc/magic_values.hpp"
-#include "sparrow_ipc/output_stream.hpp"
 #include "sparrow_ipc/serialize_utils.hpp"
 #include "sparrow_ipc/utils.hpp"
 

include/sparrow_ipc/serialize.hpp

@@ -8,7 +8,6 @@
 #include "Message_generated.h"
 #include "sparrow_ipc/any_output_stream.hpp"
 #include "sparrow_ipc/config/config.hpp"
-#include "sparrow_ipc/output_stream.hpp"
 #include "sparrow_ipc/utils.hpp"
 
 namespace sparrow_ipc
@@ -169,17 +168,5 @@ namespace sparrow_ipc
      */
     [[nodiscard]] SPARROW_IPC_API int64_t calculate_body_size(const sparrow::record_batch& record_batch);
 
-
-    /**
-     * @brief Adds padding bytes to an output stream to ensure 8-byte alignment.
-     *
-     * This function appends zero bytes to the end of the provided stream until
-     * its size is a multiple of 8. This is often required for proper memory
-     * alignment in binary formats such as Apache Arrow IPC.
-     *
-     * @param stream The output stream where padding bytes will be added
-     */
-    SPARROW_IPC_API void add_padding(output_stream& stream);
-
     SPARROW_IPC_API std::vector<sparrow::data_type> get_column_dtypes(const sparrow::record_batch& rb);
 }

include/sparrow_ipc/serialize_utils.hpp

@@ -4,7 +4,6 @@
 #include <doctest/doctest.h>
 #include <sparrow/record_batch.hpp>
 
-#include "sparrow_ipc/any_output_stream.hpp"
 #include "sparrow_ipc/memory_output_stream.hpp"
 #include "sparrow_ipc/serializer.hpp"
 #include "sparrow_ipc_tests_helpers.hpp"