Preserve transform_width and remove_whitespace state across a copy

Same defect class as the `xml_escape` / `xml_unescape` fix in the
previous commit: a hand-written copy constructor, written for Intel 7.1,
that silently dropped part of the iterator's state.

The bug is not reachable through the archive save/load paths, which
drive the base64 pipeline with a single iterator instance, but these
iterators are public and meant to be composed, and `std::copy` and
buffered adaptors (as in issue #229) copy an iterator in mid stream.
Remove both hand-written copy constructors and use the compiler-
generated ones, which copy the full state.

Refs #229.

Author: gennaroprota

include/boost/archive/iterators/remove_whitespace.hpp

@@ -154,10 +154,6 @@ class remove_whitespace :
     remove_whitespace(T start) :
         super_t(Base(static_cast< T >(start)))
     {}
-    // intel 7.1 doesn't like default copy constructor
-    remove_whitespace(const remove_whitespace & rhs) :
-        super_t(rhs.base_reference())
-    {}
 };
 
 } // namespace iterators

include/boost/archive/iterators/transform_width.hpp

@@ -119,15 +119,6 @@ class transform_width :
         m_remaining_bits(0),
         m_end_of_sequence(false)
     {}
-    // intel 7.1 doesn't like default copy constructor
-    transform_width(const transform_width & rhs) :
-        super_t(rhs.base_reference()),
-        m_buffer_out_full(rhs.m_buffer_out_full),
-        m_buffer_out(rhs.m_buffer_out),
-        m_buffer_in(rhs.m_buffer_in),
-        m_remaining_bits(rhs.m_remaining_bits),
-        m_end_of_sequence(false)
-    {}
 };
 
 template<

test/Jamfile.v2

@@ -161,6 +161,7 @@ if ! $(BOOST_ARCHIVE_LIST) {
         [ test-bsl-run test_mult_archive_types : : : [ requires std_wstreambuf ] ]
         [ test-bsl-run test_iterators : : : [ requires std_wstreambuf ] ]
         [ test-bsl-run test_iterators_base64 ]
+        [ test-bsl-run test_iterators_copy ]
         [ test-bsl-run test_smart_cast ]
         [ test-bsl-run test_codecvt_null ]
         [ test-bsl-run test_singleton ]

test/test_iterators_copy.cpp

@@ -0,0 +1,107 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// test_iterators_copy.cpp
+
+// Copyright 2026 Gennaro Prota
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// Regression test for issue #229.
+
+#include <algorithm>
+#include <cstdlib>
+#include <cstddef>
+#include <list>
+
+#include <boost/config.hpp>
+
+#include <boost/archive/iterators/binary_from_base64.hpp>
+#include <boost/archive/iterators/base64_from_binary.hpp>
+#include <boost/archive/iterators/insert_linebreaks.hpp>
+#include <boost/archive/iterators/remove_whitespace.hpp>
+#include <boost/archive/iterators/transform_width.hpp>
+
+#include "test_tools.hpp"
+
+// Traverse [it, end) but copy construct the iterator at every step and
+// continue from the copy, the way std::copy unwraps an iterator.  The `== end`
+// comparison is what makes transform_width set its end-of-sequence flag, so we
+// must keep comparing against end for the copy to have that state to preserve.
+template<class Iterator, class Output>
+void drain_to_end_by_copy(Iterator it, Iterator end, Output out){
+    while(! (it == end)){
+        Iterator cur = it;   // copy constructor under test
+        *out++ = *cur;
+        ++cur;
+        it = cur;
+    }
+}
+
+// Read n elements, copy constructing the iterator at every step.  Used for the
+// decode pipeline, which has no end-of-sequence padding but does drive
+// remove_whitespace (whose copy must preserve its cached-value flag).
+template<class Iterator, class Output>
+void drain_n_by_copy(Iterator it, std::size_t n, Output out){
+    for(std::size_t i = 0; i < n; ++i){
+        Iterator cur = it;   // copy constructor under test
+        *out++ = *cur;
+        ++cur;
+        it = cur;
+    }
+}
+
+template<class CharType>
+void test_base64_copy(unsigned int size){
+    CharType rawdata[150];
+    for(unsigned int i = 0; i < size; ++i)
+        rawdata[i] = static_cast<CharType>(std::rand() & 0xff);
+
+    typedef boost::archive::iterators::insert_linebreaks<
+        boost::archive::iterators::base64_from_binary<
+            boost::archive::iterators::transform_width<
+                CharType *, 6, sizeof(CharType) * 8
+            >
+        >, 76
+    > encode;
+
+    // Straight encode (single iterator instance, as std::copy drives it).
+    std::list<CharType> plain;
+    std::copy(
+        encode(rawdata), encode(rawdata + size), std::back_inserter(plain)
+    );
+
+    // Same encode, but copy constructing the iterator at every step.  Without
+    // a correct transform_width copy constructor the final (zero padded)
+    // group is produced from lost state, so the tails differ.
+    std::list<CharType> copied;
+    drain_to_end_by_copy(
+        encode(rawdata), encode(rawdata + size), std::back_inserter(copied)
+    );
+    BOOST_CHECK(plain == copied);
+
+    // Decode back to the original bytes, again copy constructing at every
+    // step.  This drives remove_whitespace over the line breaks inserted
+    // above (present once the base64 exceeds 76 characters).
+    typedef boost::archive::iterators::transform_width<
+        boost::archive::iterators::binary_from_base64<
+            boost::archive::iterators::remove_whitespace<
+                typename std::list<CharType>::iterator
+            >
+        >, sizeof(CharType) * 8, 6
+    > decode;
+    std::list<CharType> decoded;
+    drain_n_by_copy(decode(plain.begin()), size, std::back_inserter(decoded));
+    BOOST_CHECK(std::equal(rawdata, rawdata + size, decoded.begin()));
+}
+
+int test_main(int /* argc */, char * /* argv */ []){
+    for(unsigned int s = 1; s <= 4; ++s)
+        test_base64_copy<char>(s);
+    test_base64_copy<char>(150);
+    #ifndef BOOST_NO_CWCHAR
+    for(unsigned int s = 1; s <= 4; ++s)
+        test_base64_copy<wchar_t>(s);
+    test_base64_copy<wchar_t>(150);
+    #endif
+    return EXIT_SUCCESS;
+}