From 1b70dd0415f1fe86748c689e244e46e8412aecfc Mon Sep 17 00:00:00 2001 From: Marcin Kowalczyk Date: Mon, 27 Jan 2025 15:59:40 +0100 Subject: [PATCH] Reorder overloads to put handling of `ExternalRef` directly after `absl::string_view` or `BytesRef`. Planned changes to `ExternalRef` make it more natural to put them together, followed by disambiguating overloads for other types if needed. Also, if `!std::is_convertible_v>` then there is no need to ensure that `!SupportsExternalRefWhole::value`. This is always implied. PiperOrigin-RevId: 720154616 --- riegeli/base/chain_base.h | 36 +++++----- riegeli/base/chain_details.h | 8 +-- riegeli/bytes/backward_writer.cc | 14 ++-- riegeli/bytes/backward_writer.h | 64 +++++++++--------- riegeli/bytes/chain_backward_writer.cc | 38 +++++------ riegeli/bytes/chain_backward_writer.h | 2 +- riegeli/bytes/chain_writer.cc | 38 +++++------ riegeli/bytes/chain_writer.h | 2 +- riegeli/bytes/cord_backward_writer.cc | 42 ++++++------ riegeli/bytes/cord_backward_writer.h | 2 +- riegeli/bytes/cord_writer.cc | 40 +++++------ riegeli/bytes/cord_writer.h | 2 +- riegeli/bytes/limiting_backward_writer.cc | 22 +++--- riegeli/bytes/limiting_backward_writer.h | 2 +- riegeli/bytes/limiting_writer.cc | 22 +++--- riegeli/bytes/limiting_writer.h | 2 +- riegeli/bytes/null_backward_writer.cc | 18 ++--- riegeli/bytes/null_backward_writer.h | 2 +- riegeli/bytes/null_writer.cc | 18 ++--- riegeli/bytes/null_writer.h | 2 +- riegeli/bytes/position_shifting_writer.cc | 14 ++-- riegeli/bytes/position_shifting_writer.h | 2 +- riegeli/bytes/prefix_limiting_writer.cc | 14 ++-- riegeli/bytes/prefix_limiting_writer.h | 2 +- riegeli/bytes/pushable_backward_writer.cc | 62 ++++++++--------- riegeli/bytes/pushable_backward_writer.h | 4 +- riegeli/bytes/pushable_writer.cc | 62 ++++++++--------- riegeli/bytes/pushable_writer.h | 4 +- riegeli/bytes/resizable_writer.cc | 42 ++++++------ riegeli/bytes/resizable_writer.h | 2 +- riegeli/bytes/restricted_chain_writer.cc | 36 +++++----- riegeli/bytes/restricted_chain_writer.h | 2 +- riegeli/bytes/string_writer.cc | 54 +++++++-------- riegeli/bytes/string_writer.h | 2 +- riegeli/bytes/wrapping_backward_writer.cc | 14 ++-- riegeli/bytes/wrapping_backward_writer.h | 2 +- riegeli/bytes/wrapping_writer.cc | 14 ++-- riegeli/bytes/wrapping_writer.h | 2 +- riegeli/bytes/writer.cc | 14 ++-- riegeli/bytes/writer.h | 64 +++++++++--------- riegeli/chunk_encoding/chunk_encoder.h | 8 +-- riegeli/chunk_encoding/deferred_encoder.cc | 8 +-- riegeli/chunk_encoding/deferred_encoder.h | 2 +- riegeli/chunk_encoding/simple_encoder.cc | 8 +-- riegeli/chunk_encoding/simple_encoder.h | 2 +- riegeli/chunk_encoding/transpose_encoder.cc | 20 +++--- riegeli/chunk_encoding/transpose_encoder.h | 2 +- riegeli/digests/digesting_writer.cc | 14 ++-- riegeli/digests/digesting_writer.h | 2 +- riegeli/records/record_writer.cc | 12 ++-- riegeli/records/record_writer.h | 8 +-- riegeli/snappy/snappy_writer.cc | 74 ++++++++++----------- riegeli/snappy/snappy_writer.h | 2 +- riegeli/tensorflow/io/file_writer.cc | 26 ++++---- riegeli/tensorflow/io/file_writer.h | 2 +- 55 files changed, 487 insertions(+), 491 deletions(-) diff --git a/riegeli/base/chain_base.h b/riegeli/base/chain_base.h index eed1c9fa..aa02d44c 100644 --- a/riegeli/base/chain_base.h +++ b/riegeli/base/chain_base.h @@ -193,13 +193,13 @@ class Chain : public WithCompare { // Converts from a string-like type. explicit Chain(BytesRef src); - explicit Chain(Block src); - explicit Chain(const absl::Cord& src); - explicit Chain(absl::Cord&& src); explicit Chain(ExternalRef src); template ::value, int> = 0> explicit Chain(Src&& src); + explicit Chain(Block src); + explicit Chain(const absl::Cord& src); + explicit Chain(absl::Cord&& src); Chain(const Chain& that); Chain& operator=(const Chain& that); @@ -217,13 +217,13 @@ class Chain : public WithCompare { // constructing a temporary `Chain` and moving from it. ABSL_ATTRIBUTE_REINITIALIZES void Reset(); ABSL_ATTRIBUTE_REINITIALIZES void Reset(BytesRef src); - ABSL_ATTRIBUTE_REINITIALIZES void Reset(Block src); - ABSL_ATTRIBUTE_REINITIALIZES void Reset(const absl::Cord& src); - ABSL_ATTRIBUTE_REINITIALIZES void Reset(absl::Cord&& src); ABSL_ATTRIBUTE_REINITIALIZES void Reset(ExternalRef src); template ::value, int> = 0> ABSL_ATTRIBUTE_REINITIALIZES void Reset(Src&& src); + ABSL_ATTRIBUTE_REINITIALIZES void Reset(Block src); + ABSL_ATTRIBUTE_REINITIALIZES void Reset(const absl::Cord& src); + ABSL_ATTRIBUTE_REINITIALIZES void Reset(absl::Cord&& src); // Removes all data. ABSL_ATTRIBUTE_REINITIALIZES void Clear(); @@ -304,12 +304,6 @@ class Chain : public WithCompare { // Appends/prepends a string-like type. void Append(BytesRef src, Options options = Options()); - void Append(const Chain& src, Options options = Options()); - void Append(Chain&& src, Options options = Options()); - void Append(const Block& src, Options options = Options()); - void Append(Block&& src, Options options = Options()); - void Append(const absl::Cord& src, Options options = Options()); - void Append(absl::Cord&& src, Options options = Options()); void Append(ExternalRef src); void Append(ExternalRef src, Options options); template { template ::value, int> = 0> void Append(Src&& src, Options options); + void Append(const Chain& src, Options options = Options()); + void Append(Chain&& src, Options options = Options()); + void Append(const Block& src, Options options = Options()); + void Append(Block&& src, Options options = Options()); + void Append(const absl::Cord& src, Options options = Options()); + void Append(absl::Cord&& src, Options options = Options()); void Prepend(BytesRef src, Options options = Options()); - void Prepend(const Chain& src, Options options = Options()); - void Prepend(Chain&& src, Options options = Options()); - void Prepend(const Block& src, Options options = Options()); - void Prepend(Block&& src, Options options = Options()); - void Prepend(const absl::Cord& src, Options options = Options()); - void Prepend(absl::Cord&& src, Options options = Options()); void Prepend(ExternalRef src); void Prepend(ExternalRef src, Options options); template { template ::value, int> = 0> void Prepend(Src&& src, Options options); + void Prepend(const Chain& src, Options options = Options()); + void Prepend(Chain&& src, Options options = Options()); + void Prepend(const Block& src, Options options = Options()); + void Prepend(Block&& src, Options options = Options()); + void Prepend(const absl::Cord& src, Options options = Options()); + void Prepend(absl::Cord&& src, Options options = Options()); // `AppendFrom(iter, length)` is equivalent to // `Append(absl::Cord::AdvanceAndRead(&iter, length))` but more efficient. diff --git a/riegeli/base/chain_details.h b/riegeli/base/chain_details.h index 661dde7a..5f1b4871 100644 --- a/riegeli/base/chain_details.h +++ b/riegeli/base/chain_details.h @@ -961,10 +961,6 @@ constexpr size_t Chain::kExternalAllocatedSize() { inline Chain::Chain(BytesRef src) { Initialize(src); } -inline Chain::Chain(Block src) { - if (src.raw_block() != nullptr) Initialize(std::move(src)); -} - inline Chain::Chain(ExternalRef src) { std::move(src).InitializeTo(*this); } template (src)).InitializeTo(*this); } +inline Chain::Chain(Block src) { + if (src.raw_block() != nullptr) Initialize(std::move(src)); +} + inline Chain::Chain(Chain&& that) noexcept : size_(std::exchange(that.size_, 0)) { // Use `std::memcpy()` instead of copy constructor to silence diff --git a/riegeli/bytes/backward_writer.cc b/riegeli/bytes/backward_writer.cc index 243f39c8..eda13673 100644 --- a/riegeli/bytes/backward_writer.cc +++ b/riegeli/bytes/backward_writer.cc @@ -85,6 +85,13 @@ bool BackwardWriter::WriteSlow(absl::string_view src) { return true; } +bool BackwardWriter::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + return Write(absl::string_view(src)); +} + bool BackwardWriter::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of BackwardWriter::WriteSlow(Chain): " @@ -136,13 +143,6 @@ bool BackwardWriter::WriteSlow(absl::Cord&& src) { return WriteSlow(src); } -bool BackwardWriter::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - return Write(absl::string_view(src)); -} - bool BackwardWriter::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of BackwardWriter::WriteSlow(ByteFill): " diff --git a/riegeli/bytes/backward_writer.h b/riegeli/bytes/backward_writer.h index 2e88ce31..9cdd5a3a 100644 --- a/riegeli/bytes/backward_writer.h +++ b/riegeli/bytes/backward_writer.h @@ -163,14 +163,14 @@ class BackwardWriter : public Object { bool Write(BytesRef src); ABSL_ATTRIBUTE_ALWAYS_INLINE bool Write(const char* src) { return Write(absl::string_view(src)); } - bool Write(const Chain& src); - bool Write(Chain&& src); - bool Write(const absl::Cord& src); - bool Write(absl::Cord&& src); bool Write(ExternalRef src); template ::value, int> = 0> bool Write(Src&& src); + bool Write(const Chain& src); + bool Write(Chain&& src); + bool Write(const absl::Cord& src); + bool Write(absl::Cord&& src); bool Write(ByteFill src); // Writes a stringified value to the buffer and/or the destination. @@ -201,7 +201,6 @@ class BackwardWriter : public Object { absl::negation>, absl::negation>, absl::negation>, - absl::negation>, absl::negation>>::value, int> = 0> bool Write(Src&& src); @@ -376,8 +375,8 @@ class BackwardWriter : public Object { // By default: // * `WriteSlow(absl::string_view)` and `WriteSlow(ByteFill)` are // implemented in terms of `PushSlow()` - // * `WriteSlow(const Chain&)`, `WriteSlow(const absl::Cord&)`, and - // `WriteSlow(ExternalRef)` are implemented in terms of + // * `WriteSlow(ExternalRef)`, `WriteSlow(const Chain&)`, and + // `WriteSlow(const absl::Cord&)` are implemented in terms of // `WriteSlow(absl::string_view)` // * `WriteSlow(Chain&&)` is implemented in terms of // `WriteSlow(const Chain&)` @@ -387,16 +386,16 @@ class BackwardWriter : public Object { // Precondition for `WriteSlow(absl::string_view)`: // `available() < src.size()` // - // Precondition for `WriteSlow(const Chain&)`, `WriteSlow(Chain&&)`, - // `WriteSlow(const absl::Cord&)`, `WriteSlow(absl::Cord&&), - // `WriteSlow(ExternalRef)`, and `WriteSlow(ByteFill)`: + // Precondition for `WriteSlow(ExternalRef)`, `WriteSlow(const Chain&)`, + // `WriteSlow(Chain&&)`, `WriteSlow(const absl::Cord&)`, + // `WriteSlow(absl::Cord&&), and `WriteSlow(ByteFill)`: // `UnsignedMin(available(), kMaxBytesToCopy) < src.size()` virtual bool WriteSlow(absl::string_view src); + virtual bool WriteSlow(ExternalRef src); virtual bool WriteSlow(const Chain& src); virtual bool WriteSlow(Chain&& src); virtual bool WriteSlow(const absl::Cord& src); virtual bool WriteSlow(absl::Cord&& src); - virtual bool WriteSlow(ExternalRef src); virtual bool WriteSlow(ByteFill src); // Implementation of `Flush()`, except that the parameter is not defaulted, @@ -591,6 +590,27 @@ inline bool BackwardWriter::Write(BytesRef src) { return WriteSlow(src); } +inline bool BackwardWriter::Write(ExternalRef src) { + if (ABSL_PREDICT_TRUE(available() >= src.size() && + src.size() <= kMaxBytesToCopy)) { + // `std::memcpy(nullptr, _, 0)` and `std::memcpy(_, nullptr, 0)` are + // undefined. + if (ABSL_PREDICT_TRUE(!src.empty())) { + move_cursor(src.size()); + std::memcpy(cursor(), src.data(), src.size()); + } + return true; + } + AssertInitialized(cursor(), start_to_cursor()); + return WriteSlow(std::move(src)); +} + +template ::value, int>> +inline bool BackwardWriter::Write(Src&& src) { + return Write(ExternalRef(std::forward(src))); +} + inline bool BackwardWriter::Write(const Chain& src) { #ifdef MEMORY_SANITIZER for (const absl::string_view fragment : src.blocks()) { @@ -655,27 +675,6 @@ inline bool BackwardWriter::Write(absl::Cord&& src) { return WriteSlow(std::move(src)); } -inline bool BackwardWriter::Write(ExternalRef src) { - if (ABSL_PREDICT_TRUE(available() >= src.size() && - src.size() <= kMaxBytesToCopy)) { - // `std::memcpy(nullptr, _, 0)` and `std::memcpy(_, nullptr, 0)` are - // undefined. - if (ABSL_PREDICT_TRUE(!src.empty())) { - move_cursor(src.size()); - std::memcpy(cursor(), src.data(), src.size()); - } - return true; - } - AssertInitialized(cursor(), start_to_cursor()); - return WriteSlow(std::move(src)); -} - -template ::value, int>> -inline bool BackwardWriter::Write(Src&& src) { - return Write(ExternalRef(std::forward(src))); -} - inline bool BackwardWriter::Write(ByteFill src) { if (ABSL_PREDICT_TRUE(available() >= src.size() && src.size() <= kMaxBytesToCopy)) { @@ -745,7 +744,6 @@ template >, absl::negation>, absl::negation>, - absl::negation>, absl::negation>>::value, int>> inline bool BackwardWriter::Write(Src&& src) { diff --git a/riegeli/bytes/chain_backward_writer.cc b/riegeli/bytes/chain_backward_writer.cc index 4c66703f..289b6dae 100644 --- a/riegeli/bytes/chain_backward_writer.cc +++ b/riegeli/bytes/chain_backward_writer.cc @@ -80,6 +80,25 @@ bool ChainBackwardWriterBase::PushSlow(size_t min_length, return true; } +bool ChainBackwardWriterBase::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + if (ABSL_PREDICT_FALSE(!ok())) return false; + Chain& dest = *DestChain(); + RIEGELI_ASSERT_EQ(limit_pos(), dest.size()) + << "ChainBackwardWriter destination changed unexpectedly"; + SyncBuffer(dest); + if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - + IntCast(start_pos()))) { + return FailOverflow(); + } + move_start_pos(src.size()); + dest.Prepend(std::move(src), options_); + MakeBuffer(dest); + return true; +} + bool ChainBackwardWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of BackwardWriter::WriteSlow(Chain): " @@ -175,25 +194,6 @@ bool ChainBackwardWriterBase::WriteSlow(absl::Cord&& src) { return true; } -bool ChainBackwardWriterBase::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - if (ABSL_PREDICT_FALSE(!ok())) return false; - Chain& dest = *DestChain(); - RIEGELI_ASSERT_EQ(limit_pos(), dest.size()) - << "ChainBackwardWriter destination changed unexpectedly"; - SyncBuffer(dest); - if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - - IntCast(start_pos()))) { - return FailOverflow(); - } - move_start_pos(src.size()); - dest.Prepend(std::move(src), options_); - MakeBuffer(dest); - return true; -} - bool ChainBackwardWriterBase::FlushImpl(FlushType flush_type) { if (ABSL_PREDICT_FALSE(!ok())) return false; Chain& dest = *DestChain(); diff --git a/riegeli/bytes/chain_backward_writer.h b/riegeli/bytes/chain_backward_writer.h index b07e9615..b51d2a4b 100644 --- a/riegeli/bytes/chain_backward_writer.h +++ b/riegeli/bytes/chain_backward_writer.h @@ -140,11 +140,11 @@ class ChainBackwardWriterBase : public BackwardWriter { void SetWriteSizeHintImpl(absl::optional write_size_hint) override; bool PushSlow(size_t min_length, size_t recommended_length) override; using BackwardWriter::WriteSlow; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool FlushImpl(FlushType flush_type) override; bool TruncateImpl(Position new_size) override; diff --git a/riegeli/bytes/chain_writer.cc b/riegeli/bytes/chain_writer.cc index aa88024d..3751833c 100644 --- a/riegeli/bytes/chain_writer.cc +++ b/riegeli/bytes/chain_writer.cc @@ -168,10 +168,10 @@ bool ChainWriterBase::PushSlow(size_t min_length, size_t recommended_length) { return true; } -bool ChainWriterBase::WriteSlow(const Chain& src) { +bool ChainWriterBase::WriteSlow(ExternalRef src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Chain): " - "enough space available, use Write(Chain) instead"; + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; Chain& dest = *DestChain(); RIEGELI_ASSERT_LE(limit_pos(), dest.size()) @@ -183,15 +183,15 @@ bool ChainWriterBase::WriteSlow(const Chain& src) { } ShrinkTail(src.size()); move_start_pos(src.size()); - dest.Append(src, options_); + dest.Append(std::move(src), options_); MakeBuffer(dest); return true; } -bool ChainWriterBase::WriteSlow(Chain&& src) { +bool ChainWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Chain&&): " - "enough space available, use Write(Chain&&) instead"; + << "Failed precondition of Writer::WriteSlow(Chain): " + "enough space available, use Write(Chain) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; Chain& dest = *DestChain(); RIEGELI_ASSERT_LE(limit_pos(), dest.size()) @@ -203,15 +203,15 @@ bool ChainWriterBase::WriteSlow(Chain&& src) { } ShrinkTail(src.size()); move_start_pos(src.size()); - dest.Append(std::move(src), options_); + dest.Append(src, options_); MakeBuffer(dest); return true; } -bool ChainWriterBase::WriteSlow(const absl::Cord& src) { +bool ChainWriterBase::WriteSlow(Chain&& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Cord): " - "enough space available, use Write(Cord) instead"; + << "Failed precondition of Writer::WriteSlow(Chain&&): " + "enough space available, use Write(Chain&&) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; Chain& dest = *DestChain(); RIEGELI_ASSERT_LE(limit_pos(), dest.size()) @@ -223,15 +223,15 @@ bool ChainWriterBase::WriteSlow(const absl::Cord& src) { } ShrinkTail(src.size()); move_start_pos(src.size()); - dest.Append(src, options_); + dest.Append(std::move(src), options_); MakeBuffer(dest); return true; } -bool ChainWriterBase::WriteSlow(absl::Cord&& src) { +bool ChainWriterBase::WriteSlow(const absl::Cord& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Cord&&): " - "enough space available, use Write(Cord&&) instead"; + << "Failed precondition of Writer::WriteSlow(Cord): " + "enough space available, use Write(Cord) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; Chain& dest = *DestChain(); RIEGELI_ASSERT_LE(limit_pos(), dest.size()) @@ -243,15 +243,15 @@ bool ChainWriterBase::WriteSlow(absl::Cord&& src) { } ShrinkTail(src.size()); move_start_pos(src.size()); - dest.Append(std::move(src), options_); + dest.Append(src, options_); MakeBuffer(dest); return true; } -bool ChainWriterBase::WriteSlow(ExternalRef src) { +bool ChainWriterBase::WriteSlow(absl::Cord&& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; + << "Failed precondition of Writer::WriteSlow(Cord&&): " + "enough space available, use Write(Cord&&) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; Chain& dest = *DestChain(); RIEGELI_ASSERT_LE(limit_pos(), dest.size()) diff --git a/riegeli/bytes/chain_writer.h b/riegeli/bytes/chain_writer.h index 1396dd35..99274007 100644 --- a/riegeli/bytes/chain_writer.h +++ b/riegeli/bytes/chain_writer.h @@ -149,11 +149,11 @@ class ChainWriterBase : public Writer { void SetWriteSizeHintImpl(absl::optional write_size_hint) override; bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool FlushImpl(FlushType flush_type) override; bool SeekSlow(Position new_pos) override; diff --git a/riegeli/bytes/cord_backward_writer.cc b/riegeli/bytes/cord_backward_writer.cc index 4de014af..8b79aa5e 100644 --- a/riegeli/bytes/cord_backward_writer.cc +++ b/riegeli/bytes/cord_backward_writer.cc @@ -174,6 +174,27 @@ bool CordBackwardWriterBase::PushSlow(size_t min_length, return true; } +bool CordBackwardWriterBase::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + if (src.size() <= MaxBytesToCopy()) { + return BackwardWriter::WriteSlow(std::move(src)); + } + if (ABSL_PREDICT_FALSE(!ok())) return false; + absl::Cord& dest = *DestCord(); + RIEGELI_ASSERT_EQ(start_pos(), dest.size()) + << "CordBackwardWriter destination changed unexpectedly"; + SyncBuffer(dest); + if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - + IntCast(start_pos()))) { + return FailOverflow(); + } + move_start_pos(src.size()); + std::move(src).PrependTo(dest); + return true; +} + bool CordBackwardWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of BackwardWriter::WriteSlow(Chain): " @@ -262,27 +283,6 @@ bool CordBackwardWriterBase::WriteSlow(absl::Cord&& src) { return true; } -bool CordBackwardWriterBase::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - if (src.size() <= MaxBytesToCopy()) { - return BackwardWriter::WriteSlow(std::move(src)); - } - if (ABSL_PREDICT_FALSE(!ok())) return false; - absl::Cord& dest = *DestCord(); - RIEGELI_ASSERT_EQ(start_pos(), dest.size()) - << "CordBackwardWriter destination changed unexpectedly"; - SyncBuffer(dest); - if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - - IntCast(start_pos()))) { - return FailOverflow(); - } - move_start_pos(src.size()); - std::move(src).PrependTo(dest); - return true; -} - bool CordBackwardWriterBase::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of BackwardWriter::WriteSlow(ByteFill): " diff --git a/riegeli/bytes/cord_backward_writer.h b/riegeli/bytes/cord_backward_writer.h index 50c6cb37..fab4fb9b 100644 --- a/riegeli/bytes/cord_backward_writer.h +++ b/riegeli/bytes/cord_backward_writer.h @@ -141,11 +141,11 @@ class CordBackwardWriterBase : public BackwardWriter { void SetWriteSizeHintImpl(absl::optional write_size_hint) override; bool PushSlow(size_t min_length, size_t recommended_length) override; using BackwardWriter::WriteSlow; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool FlushImpl(FlushType flush_type) override; bool TruncateImpl(Position new_size) override; diff --git a/riegeli/bytes/cord_writer.cc b/riegeli/bytes/cord_writer.cc index 4ae75e0e..3649bf88 100644 --- a/riegeli/bytes/cord_writer.cc +++ b/riegeli/bytes/cord_writer.cc @@ -235,6 +235,26 @@ bool CordWriterBase::PushSlow(size_t min_length, size_t recommended_length) { return true; } +bool CordWriterBase::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + if (src.size() <= MaxBytesToCopy()) return Writer::WriteSlow(std::move(src)); + if (ABSL_PREDICT_FALSE(!ok())) return false; + absl::Cord& dest = *DestCord(); + RIEGELI_ASSERT_LE(start_pos(), dest.size()) + << "CordWriter destination changed unexpectedly"; + SyncBuffer(dest); + if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - + IntCast(start_pos()))) { + return FailOverflow(); + } + ShrinkTail(src.size()); + move_start_pos(src.size()); + std::move(src).AppendTo(dest); + return true; +} + bool CordWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(Chain): " @@ -325,26 +345,6 @@ bool CordWriterBase::WriteSlow(absl::Cord&& src) { return true; } -bool CordWriterBase::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - if (src.size() <= MaxBytesToCopy()) return Writer::WriteSlow(std::move(src)); - if (ABSL_PREDICT_FALSE(!ok())) return false; - absl::Cord& dest = *DestCord(); - RIEGELI_ASSERT_LE(start_pos(), dest.size()) - << "CordWriter destination changed unexpectedly"; - SyncBuffer(dest); - if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - - IntCast(start_pos()))) { - return FailOverflow(); - } - ShrinkTail(src.size()); - move_start_pos(src.size()); - std::move(src).AppendTo(dest); - return true; -} - bool CordWriterBase::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(ByteFill): " diff --git a/riegeli/bytes/cord_writer.h b/riegeli/bytes/cord_writer.h index 7e057b77..ebe90f9b 100644 --- a/riegeli/bytes/cord_writer.h +++ b/riegeli/bytes/cord_writer.h @@ -151,11 +151,11 @@ class CordWriterBase : public Writer { void SetWriteSizeHintImpl(absl::optional write_size_hint) override; bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool FlushImpl(FlushType flush_type) override; bool SeekSlow(Position new_pos) override; diff --git a/riegeli/bytes/limiting_backward_writer.cc b/riegeli/bytes/limiting_backward_writer.cc index 517cdea9..3adb0897 100644 --- a/riegeli/bytes/limiting_backward_writer.cc +++ b/riegeli/bytes/limiting_backward_writer.cc @@ -104,6 +104,17 @@ bool LimitingBackwardWriterBase::WriteSlow(absl::string_view src) { }); } +bool LimitingBackwardWriterBase::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + return WriteInternal(std::move(src), [](ExternalRef src, size_t length) { + Chain result(std::move(src)); + result.RemovePrefix(length); + return result; + }); +} + bool LimitingBackwardWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of BackwardWriter::WriteSlow(Chain): " @@ -148,17 +159,6 @@ bool LimitingBackwardWriterBase::WriteSlow(absl::Cord&& src) { }); } -bool LimitingBackwardWriterBase::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - return WriteInternal(std::move(src), [](ExternalRef src, size_t length) { - Chain result(std::move(src)); - result.RemovePrefix(length); - return result; - }); -} - template inline bool LimitingBackwardWriterBase::WriteInternal( Src&& src, RemovePrefix&& remove_prefix) { diff --git a/riegeli/bytes/limiting_backward_writer.h b/riegeli/bytes/limiting_backward_writer.h index bf62ad16..12febeb3 100644 --- a/riegeli/bytes/limiting_backward_writer.h +++ b/riegeli/bytes/limiting_backward_writer.h @@ -181,11 +181,11 @@ class LimitingBackwardWriterBase : public BackwardWriter { bool PushSlow(size_t min_length, size_t recommended_length) override; using BackwardWriter::WriteSlow; bool WriteSlow(absl::string_view src) override; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool TruncateImpl(Position new_size) override; diff --git a/riegeli/bytes/limiting_writer.cc b/riegeli/bytes/limiting_writer.cc index 46966db8..18785184 100644 --- a/riegeli/bytes/limiting_writer.cc +++ b/riegeli/bytes/limiting_writer.cc @@ -105,6 +105,17 @@ bool LimitingWriterBase::WriteSlow(absl::string_view src) { }); } +bool LimitingWriterBase::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + return WriteInternal(std::move(src), [](ExternalRef src, size_t length) { + Chain result(std::move(src)); + result.RemoveSuffix(length); + return result; + }); +} + bool LimitingWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(Chain): " @@ -149,17 +160,6 @@ bool LimitingWriterBase::WriteSlow(absl::Cord&& src) { }); } -bool LimitingWriterBase::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - return WriteInternal(std::move(src), [](ExternalRef src, size_t length) { - Chain result(std::move(src)); - result.RemoveSuffix(length); - return result; - }); -} - template inline bool LimitingWriterBase::WriteInternal(Src&& src, RemoveSuffix&& remove_suffix) { diff --git a/riegeli/bytes/limiting_writer.h b/riegeli/bytes/limiting_writer.h index b6a15183..abe3b22b 100644 --- a/riegeli/bytes/limiting_writer.h +++ b/riegeli/bytes/limiting_writer.h @@ -183,11 +183,11 @@ class LimitingWriterBase : public Writer { bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; bool WriteSlow(absl::string_view src) override; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool SeekSlow(Position new_pos) override; absl::optional SizeImpl() override; diff --git a/riegeli/bytes/null_backward_writer.cc b/riegeli/bytes/null_backward_writer.cc index 81ab8e5e..0eb3f1fc 100644 --- a/riegeli/bytes/null_backward_writer.cc +++ b/riegeli/bytes/null_backward_writer.cc @@ -96,10 +96,10 @@ bool NullBackwardWriter::WriteSlow(absl::string_view src) { return MakeBuffer(); } -bool NullBackwardWriter::WriteSlow(const Chain& src) { +bool NullBackwardWriter::WriteSlow(ExternalRef src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of BackwardWriter::WriteSlow(Chain): " - "enough space available, use Write(Chain) instead"; + << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; SyncBuffer(); if (ABSL_PREDICT_FALSE(src.size() > @@ -110,10 +110,10 @@ bool NullBackwardWriter::WriteSlow(const Chain& src) { return MakeBuffer(); } -bool NullBackwardWriter::WriteSlow(const absl::Cord& src) { +bool NullBackwardWriter::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of BackwardWriter::WriteSlow(Cord): " - "enough space available, use Write(Cord) instead"; + << "Failed precondition of BackwardWriter::WriteSlow(Chain): " + "enough space available, use Write(Chain) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; SyncBuffer(); if (ABSL_PREDICT_FALSE(src.size() > @@ -124,10 +124,10 @@ bool NullBackwardWriter::WriteSlow(const absl::Cord& src) { return MakeBuffer(); } -bool NullBackwardWriter::WriteSlow(ExternalRef src) { +bool NullBackwardWriter::WriteSlow(const absl::Cord& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; + << "Failed precondition of BackwardWriter::WriteSlow(Cord): " + "enough space available, use Write(Cord) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; SyncBuffer(); if (ABSL_PREDICT_FALSE(src.size() > diff --git a/riegeli/bytes/null_backward_writer.h b/riegeli/bytes/null_backward_writer.h index 9d2eb0ec..95fe26f8 100644 --- a/riegeli/bytes/null_backward_writer.h +++ b/riegeli/bytes/null_backward_writer.h @@ -72,9 +72,9 @@ class NullBackwardWriter : public BackwardWriter { bool PushSlow(size_t min_length, size_t recommended_length) override; using BackwardWriter::WriteSlow; bool WriteSlow(absl::string_view src) override; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(const absl::Cord& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool TruncateImpl(Position new_size) override; diff --git a/riegeli/bytes/null_writer.cc b/riegeli/bytes/null_writer.cc index aba30f99..03ef328d 100644 --- a/riegeli/bytes/null_writer.cc +++ b/riegeli/bytes/null_writer.cc @@ -95,10 +95,10 @@ bool NullWriter::WriteSlow(absl::string_view src) { return MakeBuffer(); } -bool NullWriter::WriteSlow(const Chain& src) { +bool NullWriter::WriteSlow(ExternalRef src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Chain): " - "enough space available, use Write(Chain) instead"; + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; SyncBuffer(); if (ABSL_PREDICT_FALSE(src.size() > @@ -109,10 +109,10 @@ bool NullWriter::WriteSlow(const Chain& src) { return MakeBuffer(); } -bool NullWriter::WriteSlow(const absl::Cord& src) { +bool NullWriter::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Cord): " - "enough space available, use Write(Cord) instead"; + << "Failed precondition of Writer::WriteSlow(Chain): " + "enough space available, use Write(Chain) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; SyncBuffer(); if (ABSL_PREDICT_FALSE(src.size() > @@ -123,10 +123,10 @@ bool NullWriter::WriteSlow(const absl::Cord& src) { return MakeBuffer(); } -bool NullWriter::WriteSlow(ExternalRef src) { +bool NullWriter::WriteSlow(const absl::Cord& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; + << "Failed precondition of Writer::WriteSlow(Cord): " + "enough space available, use Write(Cord) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; SyncBuffer(); if (ABSL_PREDICT_FALSE(src.size() > diff --git a/riegeli/bytes/null_writer.h b/riegeli/bytes/null_writer.h index 734ffc12..27f397b9 100644 --- a/riegeli/bytes/null_writer.h +++ b/riegeli/bytes/null_writer.h @@ -72,9 +72,9 @@ class NullWriter : public Writer { bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; bool WriteSlow(absl::string_view src) override; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(const absl::Cord& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool SeekSlow(Position new_pos) override; absl::optional SizeImpl() override; diff --git a/riegeli/bytes/position_shifting_writer.cc b/riegeli/bytes/position_shifting_writer.cc index 47c8bd2a..53740c61 100644 --- a/riegeli/bytes/position_shifting_writer.cc +++ b/riegeli/bytes/position_shifting_writer.cc @@ -98,6 +98,13 @@ bool PositionShiftingWriterBase::WriteSlow(absl::string_view src) { return WriteInternal(src); } +bool PositionShiftingWriterBase::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + return WriteInternal(std::move(src)); +} + bool PositionShiftingWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(Chain): " @@ -126,13 +133,6 @@ bool PositionShiftingWriterBase::WriteSlow(absl::Cord&& src) { return WriteInternal(std::move(src)); } -bool PositionShiftingWriterBase::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - return WriteInternal(std::move(src)); -} - bool PositionShiftingWriterBase::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(ByteFill): " diff --git a/riegeli/bytes/position_shifting_writer.h b/riegeli/bytes/position_shifting_writer.h index ad878be9..da70c7a0 100644 --- a/riegeli/bytes/position_shifting_writer.h +++ b/riegeli/bytes/position_shifting_writer.h @@ -105,11 +105,11 @@ class PositionShiftingWriterBase : public Writer { bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; bool WriteSlow(absl::string_view src) override; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool SeekSlow(Position new_pos) override; absl::optional SizeImpl() override; diff --git a/riegeli/bytes/prefix_limiting_writer.cc b/riegeli/bytes/prefix_limiting_writer.cc index 1d123f36..473e4836 100644 --- a/riegeli/bytes/prefix_limiting_writer.cc +++ b/riegeli/bytes/prefix_limiting_writer.cc @@ -89,6 +89,13 @@ bool PrefixLimitingWriterBase::WriteSlow(absl::string_view src) { return WriteInternal(src); } +bool PrefixLimitingWriterBase::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + return WriteInternal(std::move(src)); +} + bool PrefixLimitingWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(Chain): " @@ -117,13 +124,6 @@ bool PrefixLimitingWriterBase::WriteSlow(absl::Cord&& src) { return WriteInternal(std::move(src)); } -bool PrefixLimitingWriterBase::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - return WriteInternal(std::move(src)); -} - bool PrefixLimitingWriterBase::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(ByteFill): " diff --git a/riegeli/bytes/prefix_limiting_writer.h b/riegeli/bytes/prefix_limiting_writer.h index 0015dffc..685ada29 100644 --- a/riegeli/bytes/prefix_limiting_writer.h +++ b/riegeli/bytes/prefix_limiting_writer.h @@ -105,11 +105,11 @@ class PrefixLimitingWriterBase : public Writer { bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; bool WriteSlow(absl::string_view src) override; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool SeekSlow(Position new_pos) override; absl::optional SizeImpl() override; diff --git a/riegeli/bytes/pushable_backward_writer.cc b/riegeli/bytes/pushable_backward_writer.cc index 88d9f12e..ec993455 100644 --- a/riegeli/bytes/pushable_backward_writer.cc +++ b/riegeli/bytes/pushable_backward_writer.cc @@ -182,6 +182,18 @@ bool PushableBackwardWriter::WriteBehindScratch(absl::string_view src) { return true; } +bool PushableBackwardWriter::WriteBehindScratch(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of " + "PushableBackwardWriter::WriteBehindScratch(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + RIEGELI_ASSERT(!scratch_used()) + << "Failed precondition of " + "PushableBackwardWriter::WriteBehindScratch(ExternalRef): " + "scratch used"; + return Write(absl::string_view(src)); +} + bool PushableBackwardWriter::WriteBehindScratch(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of " @@ -253,18 +265,6 @@ bool PushableBackwardWriter::WriteBehindScratch(absl::Cord&& src) { return WriteBehindScratch(src); } -bool PushableBackwardWriter::WriteBehindScratch(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of " - "PushableBackwardWriter::WriteBehindScratch(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - RIEGELI_ASSERT(!scratch_used()) - << "Failed precondition of " - "PushableBackwardWriter::WriteBehindScratch(ExternalRef): " - "scratch used"; - return Write(absl::string_view(src)); -} - bool PushableBackwardWriter::WriteBehindScratch(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of " @@ -328,6 +328,25 @@ bool PushableBackwardWriter::WriteSlow(absl::string_view src) { return WriteBehindScratch(src); } +bool PushableBackwardWriter::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + if (ABSL_PREDICT_FALSE(scratch_used())) { + if (ABSL_PREDICT_FALSE(!SyncScratch())) return false; + if (available() >= src.size() && src.size() <= kMaxBytesToCopy) { + // `std::memcpy(nullptr, _, 0)` and `std::memcpy(_, nullptr, 0)` are + // undefined. + if (ABSL_PREDICT_TRUE(!src.empty())) { + move_cursor(src.size()); + std::memcpy(cursor(), src.data(), src.size()); + } + return true; + } + } + return WriteBehindScratch(std::move(src)); +} + bool PushableBackwardWriter::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of BackwardWriter::WriteSlow(Chain): " @@ -388,25 +407,6 @@ bool PushableBackwardWriter::WriteSlow(absl::Cord&& src) { return WriteBehindScratch(std::move(src)); } -bool PushableBackwardWriter::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - if (ABSL_PREDICT_FALSE(scratch_used())) { - if (ABSL_PREDICT_FALSE(!SyncScratch())) return false; - if (available() >= src.size() && src.size() <= kMaxBytesToCopy) { - // `std::memcpy(nullptr, _, 0)` and `std::memcpy(_, nullptr, 0)` are - // undefined. - if (ABSL_PREDICT_TRUE(!src.empty())) { - move_cursor(src.size()); - std::memcpy(cursor(), src.data(), src.size()); - } - return true; - } - } - return WriteBehindScratch(std::move(src)); -} - bool PushableBackwardWriter::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of BackwardWriter::WriteSlow(ByteFill): " diff --git a/riegeli/bytes/pushable_backward_writer.h b/riegeli/bytes/pushable_backward_writer.h index 5b40bdd1..718ef29f 100644 --- a/riegeli/bytes/pushable_backward_writer.h +++ b/riegeli/bytes/pushable_backward_writer.h @@ -128,22 +128,22 @@ class PushableBackwardWriter : public BackwardWriter { // like the corresponding `BackwardWriter` functions // `!scratch_used()` virtual bool WriteBehindScratch(absl::string_view src); + virtual bool WriteBehindScratch(ExternalRef src); virtual bool WriteBehindScratch(const Chain& src); virtual bool WriteBehindScratch(Chain&& src); virtual bool WriteBehindScratch(const absl::Cord& src); virtual bool WriteBehindScratch(absl::Cord&& src); - virtual bool WriteBehindScratch(ExternalRef src); virtual bool WriteBehindScratch(ByteFill src); virtual bool FlushBehindScratch(FlushType flush_type); virtual bool TruncateBehindScratch(Position new_size); bool PushSlow(size_t min_length, size_t recommended_length) override; bool WriteSlow(absl::string_view src) override; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool FlushImpl(FlushType flush_type) override; bool TruncateImpl(Position new_size) override; diff --git a/riegeli/bytes/pushable_writer.cc b/riegeli/bytes/pushable_writer.cc index 5e91fd82..52652c23 100644 --- a/riegeli/bytes/pushable_writer.cc +++ b/riegeli/bytes/pushable_writer.cc @@ -178,6 +178,18 @@ bool PushableWriter::WriteBehindScratch(absl::string_view src) { return true; } +bool PushableWriter::WriteBehindScratch(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of " + "PushableWriter::WriteBehindScratch(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + RIEGELI_ASSERT(!scratch_used()) + << "Failed precondition of " + "PushableWriter::WriteBehindScratch(ExternalRef): " + "scratch used"; + return Write(absl::string_view(src)); +} + bool PushableWriter::WriteBehindScratch(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of PushableWriter::WriteBehindScratch(Chain): " @@ -232,18 +244,6 @@ bool PushableWriter::WriteBehindScratch(absl::Cord&& src) { return WriteBehindScratch(src); } -bool PushableWriter::WriteBehindScratch(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of " - "PushableWriter::WriteBehindScratch(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - RIEGELI_ASSERT(!scratch_used()) - << "Failed precondition of " - "PushableWriter::WriteBehindScratch(ExternalRef): " - "scratch used"; - return Write(absl::string_view(src)); -} - bool PushableWriter::WriteBehindScratch(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of " @@ -331,6 +331,25 @@ bool PushableWriter::WriteSlow(absl::string_view src) { return WriteBehindScratch(src); } +bool PushableWriter::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + if (ABSL_PREDICT_FALSE(scratch_used())) { + if (ABSL_PREDICT_FALSE(!SyncScratch())) return false; + if (available() >= src.size() && src.size() <= kMaxBytesToCopy) { + // `std::memcpy(nullptr, _, 0)` and `std::memcpy(_, nullptr, 0)` are + // undefined. + if (ABSL_PREDICT_TRUE(!src.empty())) { + std::memcpy(cursor(), src.data(), src.size()); + move_cursor(src.size()); + } + return true; + } + } + return WriteBehindScratch(std::move(src)); +} + bool PushableWriter::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(Chain): " @@ -391,25 +410,6 @@ bool PushableWriter::WriteSlow(absl::Cord&& src) { return WriteBehindScratch(std::move(src)); } -bool PushableWriter::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - if (ABSL_PREDICT_FALSE(scratch_used())) { - if (ABSL_PREDICT_FALSE(!SyncScratch())) return false; - if (available() >= src.size() && src.size() <= kMaxBytesToCopy) { - // `std::memcpy(nullptr, _, 0)` and `std::memcpy(_, nullptr, 0)` are - // undefined. - if (ABSL_PREDICT_TRUE(!src.empty())) { - std::memcpy(cursor(), src.data(), src.size()); - move_cursor(src.size()); - } - return true; - } - } - return WriteBehindScratch(std::move(src)); -} - bool PushableWriter::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(ByteFill): " diff --git a/riegeli/bytes/pushable_writer.h b/riegeli/bytes/pushable_writer.h index f4a26874..56c46a50 100644 --- a/riegeli/bytes/pushable_writer.h +++ b/riegeli/bytes/pushable_writer.h @@ -128,11 +128,11 @@ class PushableWriter : public Writer { // like the corresponding `Writer` functions // `!scratch_used()` virtual bool WriteBehindScratch(absl::string_view src); + virtual bool WriteBehindScratch(ExternalRef src); virtual bool WriteBehindScratch(const Chain& src); virtual bool WriteBehindScratch(Chain&& src); virtual bool WriteBehindScratch(const absl::Cord& src); virtual bool WriteBehindScratch(absl::Cord&& src); - virtual bool WriteBehindScratch(ExternalRef src); virtual bool WriteBehindScratch(ByteFill src); virtual bool FlushBehindScratch(FlushType flush_type); virtual bool SeekBehindScratch(Position new_pos); @@ -142,11 +142,11 @@ class PushableWriter : public Writer { bool PushSlow(size_t min_length, size_t recommended_length) override; bool WriteSlow(absl::string_view src) override; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool FlushImpl(FlushType flush_type) override; bool SeekSlow(Position new_pos) override; diff --git a/riegeli/bytes/resizable_writer.cc b/riegeli/bytes/resizable_writer.cc index 1481b19c..b2468d51 100644 --- a/riegeli/bytes/resizable_writer.cc +++ b/riegeli/bytes/resizable_writer.cc @@ -108,10 +108,10 @@ bool ResizableWriterBase::PushSlow(size_t min_length, return true; } -bool ResizableWriterBase::WriteSlow(const Chain& src) { +bool ResizableWriterBase::WriteSlow(ExternalRef src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Chain): " - "enough space available, use Write(Chain) instead"; + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - IntCast(pos()))) { @@ -120,7 +120,7 @@ bool ResizableWriterBase::WriteSlow(const Chain& src) { if (!uses_secondary_buffer()) { GrowDestToCapacityAndMakeBuffer(); if (src.size() <= available()) { - src.CopyTo(cursor()); + std::memcpy(cursor(), src.data(), src.size()); move_cursor(src.size()); return true; } @@ -131,14 +131,14 @@ bool ResizableWriterBase::WriteSlow(const Chain& src) { SyncSecondaryBuffer(); } move_start_pos(src.size()); - secondary_buffer_.Append(src, options_); + secondary_buffer_.Append(std::move(src), options_); MakeSecondaryBuffer(); return true; } -bool ResizableWriterBase::WriteSlow(Chain&& src) { +bool ResizableWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Chain&&): " + << "Failed precondition of Writer::WriteSlow(Chain): " "enough space available, use Write(Chain) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - @@ -159,15 +159,15 @@ bool ResizableWriterBase::WriteSlow(Chain&& src) { SyncSecondaryBuffer(); } move_start_pos(src.size()); - secondary_buffer_.Append(std::move(src), options_); + secondary_buffer_.Append(src, options_); MakeSecondaryBuffer(); return true; } -bool ResizableWriterBase::WriteSlow(const absl::Cord& src) { +bool ResizableWriterBase::WriteSlow(Chain&& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Cord): " - "enough space available, use Write(Cord) instead"; + << "Failed precondition of Writer::WriteSlow(Chain&&): " + "enough space available, use Write(Chain) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - IntCast(pos()))) { @@ -176,7 +176,7 @@ bool ResizableWriterBase::WriteSlow(const absl::Cord& src) { if (!uses_secondary_buffer()) { GrowDestToCapacityAndMakeBuffer(); if (src.size() <= available()) { - cord_internal::CopyCordToArray(src, cursor()); + src.CopyTo(cursor()); move_cursor(src.size()); return true; } @@ -187,15 +187,15 @@ bool ResizableWriterBase::WriteSlow(const absl::Cord& src) { SyncSecondaryBuffer(); } move_start_pos(src.size()); - secondary_buffer_.Append(src, options_); + secondary_buffer_.Append(std::move(src), options_); MakeSecondaryBuffer(); return true; } -bool ResizableWriterBase::WriteSlow(absl::Cord&& src) { +bool ResizableWriterBase::WriteSlow(const absl::Cord& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Cord&&): " - "enough space available, use Write(Cord&&) instead"; + << "Failed precondition of Writer::WriteSlow(Cord): " + "enough space available, use Write(Cord) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - IntCast(pos()))) { @@ -215,15 +215,15 @@ bool ResizableWriterBase::WriteSlow(absl::Cord&& src) { SyncSecondaryBuffer(); } move_start_pos(src.size()); - secondary_buffer_.Append(std::move(src), options_); + secondary_buffer_.Append(src, options_); MakeSecondaryBuffer(); return true; } -bool ResizableWriterBase::WriteSlow(ExternalRef src) { +bool ResizableWriterBase::WriteSlow(absl::Cord&& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; + << "Failed precondition of Writer::WriteSlow(Cord&&): " + "enough space available, use Write(Cord&&) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - IntCast(pos()))) { @@ -232,7 +232,7 @@ bool ResizableWriterBase::WriteSlow(ExternalRef src) { if (!uses_secondary_buffer()) { GrowDestToCapacityAndMakeBuffer(); if (src.size() <= available()) { - std::memcpy(cursor(), src.data(), src.size()); + cord_internal::CopyCordToArray(src, cursor()); move_cursor(src.size()); return true; } diff --git a/riegeli/bytes/resizable_writer.h b/riegeli/bytes/resizable_writer.h index 94826685..b6db0f10 100644 --- a/riegeli/bytes/resizable_writer.h +++ b/riegeli/bytes/resizable_writer.h @@ -126,11 +126,11 @@ class ResizableWriterBase : public Writer { void SetWriteSizeHintImpl(absl::optional write_size_hint) override; bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool FlushImpl(FlushType flush_type) override; bool SeekSlow(Position new_pos) override; diff --git a/riegeli/bytes/restricted_chain_writer.cc b/riegeli/bytes/restricted_chain_writer.cc index 2352a5c9..bf939bf4 100644 --- a/riegeli/bytes/restricted_chain_writer.cc +++ b/riegeli/bytes/restricted_chain_writer.cc @@ -71,6 +71,24 @@ bool RestrictedChainWriter::PushSlow(size_t min_length, return true; } +bool RestrictedChainWriter::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + if (ABSL_PREDICT_FALSE(!ok())) return false; + RIEGELI_ASSERT_EQ(limit_pos(), dest_.size()) + << "RestrictedChainWriter destination changed unexpectedly"; + SyncBuffer(); + if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - + IntCast(start_pos()))) { + return FailOverflow(); + } + move_start_pos(src.size()); + dest_.Append(std::move(src)); + MakeBuffer(); + return true; +} + bool RestrictedChainWriter::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(Chain): " @@ -143,24 +161,6 @@ bool RestrictedChainWriter::WriteSlow(absl::Cord&& src) { return true; } -bool RestrictedChainWriter::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - if (ABSL_PREDICT_FALSE(!ok())) return false; - RIEGELI_ASSERT_EQ(limit_pos(), dest_.size()) - << "RestrictedChainWriter destination changed unexpectedly"; - SyncBuffer(); - if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - - IntCast(start_pos()))) { - return FailOverflow(); - } - move_start_pos(src.size()); - dest_.Append(std::move(src)); - MakeBuffer(); - return true; -} - bool RestrictedChainWriter::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(ByteFill): " diff --git a/riegeli/bytes/restricted_chain_writer.h b/riegeli/bytes/restricted_chain_writer.h index 206e6520..85dbf0d5 100644 --- a/riegeli/bytes/restricted_chain_writer.h +++ b/riegeli/bytes/restricted_chain_writer.h @@ -66,11 +66,11 @@ class RestrictedChainWriter : public Writer { void Done() override; bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; private: diff --git a/riegeli/bytes/string_writer.cc b/riegeli/bytes/string_writer.cc index 46d8db05..a4120f7f 100644 --- a/riegeli/bytes/string_writer.cc +++ b/riegeli/bytes/string_writer.cc @@ -151,10 +151,10 @@ bool StringWriterBase::PushSlow(size_t min_length, size_t recommended_length) { return true; } -bool StringWriterBase::WriteSlow(const Chain& src) { +bool StringWriterBase::WriteSlow(ExternalRef src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Chain): " - "enough space available, use Write(Chain) instead"; + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; std::string& dest = *DestString(); RIEGELI_ASSERT_EQ(UnsignedMax(limit_pos(), written_size_), @@ -170,10 +170,12 @@ bool StringWriterBase::WriteSlow(const Chain& src) { const size_t new_cursor_index = cursor_index + src.size(); if (new_cursor_index <= dest.capacity()) { if (ABSL_PREDICT_FALSE(new_cursor_index <= dest.size())) { - src.CopyTo(&dest[cursor_index]); + std::memcpy(&dest[cursor_index], src.data(), src.size()); } else { dest.erase(cursor_index); - src.AppendTo(dest); + // TODO: When `absl::string_view` becomes C++17 + // `std::string_view`: `dest.append(absl::string_view(src))` + dest.append(src.data(), src.size()); } GrowDestToCapacityAndMakeBuffer(dest, new_cursor_index); return true; @@ -184,14 +186,14 @@ bool StringWriterBase::WriteSlow(const Chain& src) { SyncSecondaryBuffer(); } move_start_pos(src.size()); - secondary_buffer_.Append(src, options_); + secondary_buffer_.Append(std::move(src), options_); MakeSecondaryBuffer(); return true; } -bool StringWriterBase::WriteSlow(Chain&& src) { +bool StringWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Chain&&): " + << "Failed precondition of Writer::WriteSlow(Chain): " "enough space available, use Write(Chain) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; std::string& dest = *DestString(); @@ -211,7 +213,7 @@ bool StringWriterBase::WriteSlow(Chain&& src) { src.CopyTo(&dest[cursor_index]); } else { dest.erase(cursor_index); - std::move(src).AppendTo(dest); + src.AppendTo(dest); } GrowDestToCapacityAndMakeBuffer(dest, new_cursor_index); return true; @@ -222,15 +224,15 @@ bool StringWriterBase::WriteSlow(Chain&& src) { SyncSecondaryBuffer(); } move_start_pos(src.size()); - secondary_buffer_.Append(std::move(src), options_); + secondary_buffer_.Append(src, options_); MakeSecondaryBuffer(); return true; } -bool StringWriterBase::WriteSlow(const absl::Cord& src) { +bool StringWriterBase::WriteSlow(Chain&& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Cord): " - "enough space available, use Write(Cord) instead"; + << "Failed precondition of Writer::WriteSlow(Chain&&): " + "enough space available, use Write(Chain) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; std::string& dest = *DestString(); RIEGELI_ASSERT_EQ(UnsignedMax(limit_pos(), written_size_), @@ -246,10 +248,10 @@ bool StringWriterBase::WriteSlow(const absl::Cord& src) { const size_t new_cursor_index = cursor_index + src.size(); if (new_cursor_index <= dest.capacity()) { if (ABSL_PREDICT_FALSE(new_cursor_index <= dest.size())) { - cord_internal::CopyCordToArray(src, &dest[cursor_index]); + src.CopyTo(&dest[cursor_index]); } else { dest.erase(cursor_index); - cord_internal::AppendCordToString(src, dest); + std::move(src).AppendTo(dest); } GrowDestToCapacityAndMakeBuffer(dest, new_cursor_index); return true; @@ -260,15 +262,15 @@ bool StringWriterBase::WriteSlow(const absl::Cord& src) { SyncSecondaryBuffer(); } move_start_pos(src.size()); - secondary_buffer_.Append(src, options_); + secondary_buffer_.Append(std::move(src), options_); MakeSecondaryBuffer(); return true; } -bool StringWriterBase::WriteSlow(absl::Cord&& src) { +bool StringWriterBase::WriteSlow(const absl::Cord& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Cord&&): " - "enough space available, use Write(Cord&&) instead"; + << "Failed precondition of Writer::WriteSlow(Cord): " + "enough space available, use Write(Cord) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; std::string& dest = *DestString(); RIEGELI_ASSERT_EQ(UnsignedMax(limit_pos(), written_size_), @@ -298,15 +300,15 @@ bool StringWriterBase::WriteSlow(absl::Cord&& src) { SyncSecondaryBuffer(); } move_start_pos(src.size()); - secondary_buffer_.Append(std::move(src), options_); + secondary_buffer_.Append(src, options_); MakeSecondaryBuffer(); return true; } -bool StringWriterBase::WriteSlow(ExternalRef src) { +bool StringWriterBase::WriteSlow(absl::Cord&& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; + << "Failed precondition of Writer::WriteSlow(Cord&&): " + "enough space available, use Write(Cord&&) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; std::string& dest = *DestString(); RIEGELI_ASSERT_EQ(UnsignedMax(limit_pos(), written_size_), @@ -322,12 +324,10 @@ bool StringWriterBase::WriteSlow(ExternalRef src) { const size_t new_cursor_index = cursor_index + src.size(); if (new_cursor_index <= dest.capacity()) { if (ABSL_PREDICT_FALSE(new_cursor_index <= dest.size())) { - std::memcpy(&dest[cursor_index], src.data(), src.size()); + cord_internal::CopyCordToArray(src, &dest[cursor_index]); } else { dest.erase(cursor_index); - // TODO: When `absl::string_view` becomes C++17 - // `std::string_view`: `dest.append(absl::string_view(src))` - dest.append(src.data(), src.size()); + cord_internal::AppendCordToString(src, dest); } GrowDestToCapacityAndMakeBuffer(dest, new_cursor_index); return true; diff --git a/riegeli/bytes/string_writer.h b/riegeli/bytes/string_writer.h index e0b38d41..3732b2a2 100644 --- a/riegeli/bytes/string_writer.h +++ b/riegeli/bytes/string_writer.h @@ -98,11 +98,11 @@ class StringWriterBase : public Writer { void SetWriteSizeHintImpl(absl::optional write_size_hint) override; bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool FlushImpl(FlushType flush_type) override; bool SeekSlow(Position new_pos) override; diff --git a/riegeli/bytes/wrapping_backward_writer.cc b/riegeli/bytes/wrapping_backward_writer.cc index 28baa199..1e78cf58 100644 --- a/riegeli/bytes/wrapping_backward_writer.cc +++ b/riegeli/bytes/wrapping_backward_writer.cc @@ -73,6 +73,13 @@ bool WrappingBackwardWriterBase::WriteSlow(absl::string_view src) { return WriteInternal(src); } +bool WrappingBackwardWriterBase::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + return WriteInternal(std::move(src)); +} + bool WrappingBackwardWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of BackwardWriter::WriteSlow(Chain): " @@ -101,13 +108,6 @@ bool WrappingBackwardWriterBase::WriteSlow(absl::Cord&& src) { return WriteInternal(std::move(src)); } -bool WrappingBackwardWriterBase::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of BackwardWriter::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - return WriteInternal(std::move(src)); -} - bool WrappingBackwardWriterBase::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of BackwardWriter::WriteSlow(ByteFill): " diff --git a/riegeli/bytes/wrapping_backward_writer.h b/riegeli/bytes/wrapping_backward_writer.h index e658bc83..5463d370 100644 --- a/riegeli/bytes/wrapping_backward_writer.h +++ b/riegeli/bytes/wrapping_backward_writer.h @@ -68,11 +68,11 @@ class WrappingBackwardWriterBase : public BackwardWriter { bool PushSlow(size_t min_length, size_t recommended_length) override; using BackwardWriter::WriteSlow; bool WriteSlow(absl::string_view src) override; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool TruncateImpl(Position new_size) override; diff --git a/riegeli/bytes/wrapping_writer.cc b/riegeli/bytes/wrapping_writer.cc index 12c72c37..bb44bd87 100644 --- a/riegeli/bytes/wrapping_writer.cc +++ b/riegeli/bytes/wrapping_writer.cc @@ -74,6 +74,13 @@ bool WrappingWriterBase::WriteSlow(absl::string_view src) { return WriteInternal(src); } +bool WrappingWriterBase::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + return WriteInternal(std::move(src)); +} + bool WrappingWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(Chain): " @@ -102,13 +109,6 @@ bool WrappingWriterBase::WriteSlow(absl::Cord&& src) { return WriteInternal(std::move(src)); } -bool WrappingWriterBase::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - return WriteInternal(std::move(src)); -} - bool WrappingWriterBase::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(ByteFill): " diff --git a/riegeli/bytes/wrapping_writer.h b/riegeli/bytes/wrapping_writer.h index 28fcc0cb..a824d0d4 100644 --- a/riegeli/bytes/wrapping_writer.h +++ b/riegeli/bytes/wrapping_writer.h @@ -71,11 +71,11 @@ class WrappingWriterBase : public Writer { bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; bool WriteSlow(absl::string_view src) override; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool SeekSlow(Position new_pos) override; absl::optional SizeImpl() override; diff --git a/riegeli/bytes/writer.cc b/riegeli/bytes/writer.cc index afb7236e..1e8d75b0 100644 --- a/riegeli/bytes/writer.cc +++ b/riegeli/bytes/writer.cc @@ -83,6 +83,13 @@ bool Writer::WriteSlow(absl::string_view src) { return true; } +bool Writer::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + return Write(absl::string_view(src)); +} + bool Writer::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(Chain): " @@ -125,13 +132,6 @@ bool Writer::WriteSlow(absl::Cord&& src) { return WriteSlow(src); } -bool Writer::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - return Write(absl::string_view(src)); -} - bool Writer::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(ByteFill): " diff --git a/riegeli/bytes/writer.h b/riegeli/bytes/writer.h index 6995dc0a..199d0c30 100644 --- a/riegeli/bytes/writer.h +++ b/riegeli/bytes/writer.h @@ -275,14 +275,14 @@ class Writer : public Object { bool Write(BytesRef src); ABSL_ATTRIBUTE_ALWAYS_INLINE bool Write(const char* src) { return Write(absl::string_view(src)); } - bool Write(const Chain& src); - bool Write(Chain&& src); - bool Write(const absl::Cord& src); - bool Write(absl::Cord&& src); bool Write(ExternalRef src); template ::value, int> = 0> bool Write(Src&& src); + bool Write(const Chain& src); + bool Write(Chain&& src); + bool Write(const absl::Cord& src); + bool Write(absl::Cord&& src); bool Write(ByteFill src); // Writes a stringified value to the buffer and/or the destination. @@ -313,7 +313,6 @@ class Writer : public Object { absl::negation>, absl::negation>, absl::negation>, - absl::negation>, absl::negation>>::value, int> = 0> bool Write(Src&& src); @@ -535,8 +534,8 @@ class Writer : public Object { // By default: // * `WriteSlow(absl::string_view)` and `WriteSlow(ByteFill)` are // implemented in terms of `PushSlow()` - // * `WriteSlow(const Chain&)`, `WriteSlow(const absl::Cord&)`, and - // `WriteSlow(ExternalRef)` are implemented in terms of + // * `WriteSlow(ExternalRef)`, `WriteSlow(const Chain&)`, and + // `WriteSlow(const absl::Cord&)` are implemented in terms of // `WriteSlow(absl::string_view)` // * `WriteSlow(Chain&&)` is implemented in terms of // `WriteSlow(const Chain&)` @@ -546,16 +545,16 @@ class Writer : public Object { // Precondition for `WriteSlow(absl::string_view)`: // `available() < src.size()` // - // Precondition for `WriteSlow(const Chain&)`, `WriteSlow(Chain&&)`, - // `WriteSlow(const absl::Cord&)`, `WriteSlow(absl::Cord&&), and - // `WriteSlow(ExternalRef)`, and `WriteSlow(ByteFill)`: + // Precondition for `WriteSlow(ExternalRef)`, `WriteSlow(const Chain&)`, + // `WriteSlow(Chain&&)`, `WriteSlow(const absl::Cord&)`, + // `WriteSlow(absl::Cord&&), and `WriteSlow(ByteFill)`: // `UnsignedMin(available(), kMaxBytesToCopy) < src.size()` virtual bool WriteSlow(absl::string_view src); + virtual bool WriteSlow(ExternalRef src); virtual bool WriteSlow(const Chain& src); virtual bool WriteSlow(Chain&& src); virtual bool WriteSlow(const absl::Cord& src); virtual bool WriteSlow(absl::Cord&& src); - virtual bool WriteSlow(ExternalRef src); virtual bool WriteSlow(ByteFill src); // Implementation of `Flush()`, except that the parameter is not defaulted, @@ -806,6 +805,27 @@ inline bool Writer::Write(BytesRef src) { return WriteSlow(src); } +inline bool Writer::Write(ExternalRef src) { + if (ABSL_PREDICT_TRUE(available() >= src.size() && + src.size() <= kMaxBytesToCopy)) { + // `std::memcpy(nullptr, _, 0)` and `std::memcpy(_, nullptr, 0)` are + // undefined. + if (ABSL_PREDICT_TRUE(!src.empty())) { + std::memcpy(cursor(), src.data(), src.size()); + move_cursor(src.size()); + } + return true; + } + AssertInitialized(start(), start_to_cursor()); + return WriteSlow(std::move(src)); +} + +template ::value, int>> +inline bool Writer::Write(Src&& src) { + return Write(ExternalRef(std::forward(src))); +} + inline bool Writer::Write(const Chain& src) { #ifdef MEMORY_SANITIZER for (const absl::string_view fragment : src.blocks()) { @@ -870,27 +890,6 @@ inline bool Writer::Write(absl::Cord&& src) { return WriteSlow(std::move(src)); } -inline bool Writer::Write(ExternalRef src) { - if (ABSL_PREDICT_TRUE(available() >= src.size() && - src.size() <= kMaxBytesToCopy)) { - // `std::memcpy(nullptr, _, 0)` and `std::memcpy(_, nullptr, 0)` are - // undefined. - if (ABSL_PREDICT_TRUE(!src.empty())) { - std::memcpy(cursor(), src.data(), src.size()); - move_cursor(src.size()); - } - return true; - } - AssertInitialized(start(), start_to_cursor()); - return WriteSlow(std::move(src)); -} - -template ::value, int>> -inline bool Writer::Write(Src&& src) { - return Write(ExternalRef(std::forward(src))); -} - inline bool Writer::Write(ByteFill src) { if (ABSL_PREDICT_TRUE(available() >= src.size() && src.size() <= kMaxBytesToCopy)) { @@ -960,7 +959,6 @@ template >, absl::negation>, absl::negation>, - absl::negation>, absl::negation>>::value, int>> inline bool Writer::Write(Src&& src) { diff --git a/riegeli/chunk_encoding/chunk_encoder.h b/riegeli/chunk_encoding/chunk_encoder.h index de5376f4..98dc68e7 100644 --- a/riegeli/chunk_encoding/chunk_encoder.h +++ b/riegeli/chunk_encoding/chunk_encoder.h @@ -62,14 +62,14 @@ class ChunkEncoder : public Object { ABSL_ATTRIBUTE_ALWAYS_INLINE bool AddRecord(const char* record) { return AddRecord(absl::string_view(record)); } - virtual bool AddRecord(const Chain& record) = 0; - virtual bool AddRecord(Chain&& record); - virtual bool AddRecord(const absl::Cord& record) = 0; - virtual bool AddRecord(absl::Cord&& record); virtual bool AddRecord(ExternalRef record) = 0; template ::value, int> = 0> bool AddRecord(Src&& src); + virtual bool AddRecord(const Chain& record) = 0; + virtual bool AddRecord(Chain&& record); + virtual bool AddRecord(const absl::Cord& record) = 0; + virtual bool AddRecord(absl::Cord&& record); // Add multiple records, expressed as concatenated record values and sorted // record end positions. diff --git a/riegeli/chunk_encoding/deferred_encoder.cc b/riegeli/chunk_encoding/deferred_encoder.cc index b498b61b..acbd8056 100644 --- a/riegeli/chunk_encoding/deferred_encoder.cc +++ b/riegeli/chunk_encoding/deferred_encoder.cc @@ -76,6 +76,10 @@ bool DeferredEncoder::AddRecord(BytesRef record) { return AddRecordImpl(record); } +bool DeferredEncoder::AddRecord(ExternalRef record) { + return AddRecordImpl(std::move(record)); +} + bool DeferredEncoder::AddRecord(const Chain& record) { return AddRecordImpl(record); } @@ -92,10 +96,6 @@ bool DeferredEncoder::AddRecord(absl::Cord&& record) { return AddRecordImpl(std::move(record)); } -bool DeferredEncoder::AddRecord(ExternalRef record) { - return AddRecordImpl(std::move(record)); -} - template bool DeferredEncoder::AddRecordImpl(Record&& record) { if (ABSL_PREDICT_FALSE(!ok())) return false; diff --git a/riegeli/chunk_encoding/deferred_encoder.h b/riegeli/chunk_encoding/deferred_encoder.h index 5a134e4c..99966166 100644 --- a/riegeli/chunk_encoding/deferred_encoder.h +++ b/riegeli/chunk_encoding/deferred_encoder.h @@ -48,11 +48,11 @@ class DeferredEncoder : public ChunkEncoder { bool AddRecord(const google::protobuf::MessageLite& record, SerializeOptions serialize_options) override; bool AddRecord(BytesRef record) override; + bool AddRecord(ExternalRef record) override; bool AddRecord(const Chain& record) override; bool AddRecord(Chain&& record) override; bool AddRecord(const absl::Cord& record) override; bool AddRecord(absl::Cord&& record) override; - bool AddRecord(ExternalRef record) override; bool AddRecords(Chain records, std::vector limits) override; diff --git a/riegeli/chunk_encoding/simple_encoder.cc b/riegeli/chunk_encoding/simple_encoder.cc index b19cd54e..84231d53 100644 --- a/riegeli/chunk_encoding/simple_encoder.cc +++ b/riegeli/chunk_encoding/simple_encoder.cc @@ -89,6 +89,10 @@ bool SimpleEncoder::AddRecord(const google::protobuf::MessageLite& record, bool SimpleEncoder::AddRecord(BytesRef record) { return AddRecordImpl(record); } +bool SimpleEncoder::AddRecord(ExternalRef record) { + return AddRecordImpl(std::move(record)); +} + bool SimpleEncoder::AddRecord(const Chain& record) { return AddRecordImpl(record); } @@ -105,10 +109,6 @@ bool SimpleEncoder::AddRecord(absl::Cord&& record) { return AddRecordImpl(std::move(record)); } -bool SimpleEncoder::AddRecord(ExternalRef record) { - return AddRecordImpl(std::move(record)); -} - template bool SimpleEncoder::AddRecordImpl(Record&& record) { if (ABSL_PREDICT_FALSE(!ok())) return false; diff --git a/riegeli/chunk_encoding/simple_encoder.h b/riegeli/chunk_encoding/simple_encoder.h index ce1c9bef..0839904c 100644 --- a/riegeli/chunk_encoding/simple_encoder.h +++ b/riegeli/chunk_encoding/simple_encoder.h @@ -109,11 +109,11 @@ class SimpleEncoder : public ChunkEncoder { bool AddRecord(const google::protobuf::MessageLite& record, SerializeOptions serialize_options) override; bool AddRecord(BytesRef record) override; + bool AddRecord(ExternalRef record) override; bool AddRecord(const Chain& record) override; bool AddRecord(Chain&& record) override; bool AddRecord(const absl::Cord& record) override; bool AddRecord(absl::Cord&& record) override; - bool AddRecord(ExternalRef record) override; bool AddRecords(Chain records, std::vector limits) override; diff --git a/riegeli/chunk_encoding/transpose_encoder.cc b/riegeli/chunk_encoding/transpose_encoder.cc index 28246f86..1013788c 100644 --- a/riegeli/chunk_encoding/transpose_encoder.cc +++ b/riegeli/chunk_encoding/transpose_encoder.cc @@ -222,16 +222,6 @@ bool TransposeEncoder::AddRecord(BytesRef record) { return AddRecordInternal(reader); } -bool TransposeEncoder::AddRecord(const Chain& record) { - ChainReader<> reader(&record); - return AddRecordInternal(reader); -} - -bool TransposeEncoder::AddRecord(const absl::Cord& record) { - CordReader<> reader(&record); - return AddRecordInternal(reader); -} - bool TransposeEncoder::AddRecord(ExternalRef record) { if (record.size() <= kMaxBytesToCopy) { StringReader<> reader(record); @@ -242,6 +232,16 @@ bool TransposeEncoder::AddRecord(ExternalRef record) { } } +bool TransposeEncoder::AddRecord(const Chain& record) { + ChainReader<> reader(&record); + return AddRecordInternal(reader); +} + +bool TransposeEncoder::AddRecord(const absl::Cord& record) { + CordReader<> reader(&record); + return AddRecordInternal(reader); +} + bool TransposeEncoder::AddRecords(Chain records, std::vector limits) { RIEGELI_ASSERT_EQ(limits.empty() ? 0u : limits.back(), records.size()) << "Failed precondition of ChunkEncoder::AddRecords(): " diff --git a/riegeli/chunk_encoding/transpose_encoder.h b/riegeli/chunk_encoding/transpose_encoder.h index 171a5a2a..dbde4b12 100644 --- a/riegeli/chunk_encoding/transpose_encoder.h +++ b/riegeli/chunk_encoding/transpose_encoder.h @@ -131,9 +131,9 @@ class TransposeEncoder : public ChunkEncoder { // broken down into columns. using ChunkEncoder::AddRecord; bool AddRecord(BytesRef record) override; + bool AddRecord(ExternalRef record) override; bool AddRecord(const Chain& record) override; bool AddRecord(const absl::Cord& record) override; - bool AddRecord(ExternalRef record) override; bool AddRecords(Chain records, std::vector limits) override; diff --git a/riegeli/digests/digesting_writer.cc b/riegeli/digests/digesting_writer.cc index 748631a6..73024bd2 100644 --- a/riegeli/digests/digesting_writer.cc +++ b/riegeli/digests/digesting_writer.cc @@ -95,6 +95,13 @@ bool DigestingWriterBase::WriteSlow(absl::string_view src) { return write_ok; } +bool DigestingWriterBase::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + return WriteInternal(std::move(src)); +} + bool DigestingWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(Chain): " @@ -123,13 +130,6 @@ bool DigestingWriterBase::WriteSlow(absl::Cord&& src) { return WriteInternal(std::move(src)); } -bool DigestingWriterBase::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - return WriteInternal(std::move(src)); -} - bool DigestingWriterBase::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(ByteFill): " diff --git a/riegeli/digests/digesting_writer.h b/riegeli/digests/digesting_writer.h index 6bd15e4c..5ad77850 100644 --- a/riegeli/digests/digesting_writer.h +++ b/riegeli/digests/digesting_writer.h @@ -88,11 +88,11 @@ class DigestingWriterBase : public Writer { bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; bool WriteSlow(absl::string_view src) override; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; Reader* ReadModeImpl(Position initial_pos) override; diff --git a/riegeli/records/record_writer.cc b/riegeli/records/record_writer.cc index a8878e55..bdd13a4f 100644 --- a/riegeli/records/record_writer.cc +++ b/riegeli/records/record_writer.cc @@ -932,6 +932,12 @@ bool RecordWriterBase::WriteRecord(BytesRef record) { return WriteRecordImpl(record.size(), record); } +bool RecordWriterBase::WriteRecord(ExternalRef record) { + if (ABSL_PREDICT_FALSE(!ok())) return false; + const size_t size = record.size(); + return WriteRecordImpl(size, std::move(record)); +} + bool RecordWriterBase::WriteRecord(const Chain& record) { if (ABSL_PREDICT_FALSE(!ok())) return false; return WriteRecordImpl(record.size(), record); @@ -954,12 +960,6 @@ bool RecordWriterBase::WriteRecord(absl::Cord&& record) { return WriteRecordImpl(size, std::move(record)); } -bool RecordWriterBase::WriteRecord(ExternalRef record) { - if (ABSL_PREDICT_FALSE(!ok())) return false; - const size_t size = record.size(); - return WriteRecordImpl(size, std::move(record)); -} - template inline bool RecordWriterBase::WriteRecordImpl(size_t size, Args&&... args) { last_record_ = LastRecordIsInvalid(); diff --git a/riegeli/records/record_writer.h b/riegeli/records/record_writer.h index 6bb7e6cf..36ba926c 100644 --- a/riegeli/records/record_writer.h +++ b/riegeli/records/record_writer.h @@ -472,14 +472,14 @@ class RecordWriterBase : public Object { bool WriteRecord(const google::protobuf::MessageLite& record, SerializeOptions serialize_options = SerializeOptions()); bool WriteRecord(BytesRef record); - bool WriteRecord(const Chain& record); - bool WriteRecord(Chain&& record); - bool WriteRecord(const absl::Cord& record); - bool WriteRecord(absl::Cord&& record); bool WriteRecord(ExternalRef record); template ::value, int> = 0> bool WriteRecord(Src&& src); + bool WriteRecord(const Chain& record); + bool WriteRecord(Chain&& record); + bool WriteRecord(const absl::Cord& record); + bool WriteRecord(absl::Cord&& record); // Finalizes any open chunk and pushes buffered data to the destination. // If `Options::parallelism() > 0`, waits for any background writing to diff --git a/riegeli/snappy/snappy_writer.cc b/riegeli/snappy/snappy_writer.cc index 2f2c1b00..c471280e 100644 --- a/riegeli/snappy/snappy_writer.cc +++ b/riegeli/snappy/snappy_writer.cc @@ -139,11 +139,11 @@ bool SnappyWriterBase::PushSlow(size_t min_length, size_t recommended_length) { return true; } -bool SnappyWriterBase::WriteSlow(const Chain& src) { +bool SnappyWriterBase::WriteSlow(ExternalRef src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(Chain): " - "enough space available, use Write(Chain) instead"; - if (src.size() <= MaxBytesToCopy()) return Writer::WriteSlow(src); + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + if (src.size() <= MaxBytesToCopy()) return Writer::WriteSlow(std::move(src)); if (ABSL_PREDICT_FALSE(!ok())) return false; if (ABSL_PREDICT_FALSE(!SyncBuffer())) return false; if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - @@ -151,37 +151,23 @@ bool SnappyWriterBase::WriteSlow(const Chain& src) { return FailOverflow(); } move_start_pos(src.size()); - uncompressed_.Append(src, options_); + uncompressed_.Append(std::move(src), options_); return true; } -bool SnappyWriterBase::WriteSlow(ByteFill src) { +bool SnappyWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ByteFill): " - "enough space available, use Write(ByteFill) instead"; + << "Failed precondition of Writer::WriteSlow(Chain): " + "enough space available, use Write(Chain) instead"; + if (src.size() <= MaxBytesToCopy()) return Writer::WriteSlow(src); if (ABSL_PREDICT_FALSE(!ok())) return false; - if (ABSL_PREDICT_FALSE(IntCast(pos()) > - std::numeric_limits::max() || - src.size() > std::numeric_limits::max() - - IntCast(pos()))) { + if (ABSL_PREDICT_FALSE(!SyncBuffer())) return false; + if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - + IntCast(start_pos()))) { return FailOverflow(); } - const size_t first_length = UnsignedMin( - RoundUp(IntCast(pos())) - IntCast(pos()), - IntCast(src.size())); - if (first_length > 0) { - if (ABSL_PREDICT_FALSE(!Push(first_length))) return false; - std::memset(cursor(), src.fill(), first_length); - move_cursor(first_length); - src.Extract(first_length); - } - Write(src.Extract(RoundDown(IntCast(src.size())))); - const size_t last_length = IntCast(src.size()); - if (last_length > 0) { - if (ABSL_PREDICT_FALSE(!Push(last_length))) return false; - std::memset(cursor(), src.fill(), last_length); - move_cursor(last_length); - } + move_start_pos(src.size()); + uncompressed_.Append(src, options_); return true; } @@ -243,19 +229,33 @@ bool SnappyWriterBase::WriteSlow(absl::Cord&& src) { return true; } -bool SnappyWriterBase::WriteSlow(ExternalRef src) { +bool SnappyWriterBase::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - if (src.size() <= MaxBytesToCopy()) return Writer::WriteSlow(std::move(src)); + << "Failed precondition of Writer::WriteSlow(ByteFill): " + "enough space available, use Write(ByteFill) instead"; if (ABSL_PREDICT_FALSE(!ok())) return false; - if (ABSL_PREDICT_FALSE(!SyncBuffer())) return false; - if (ABSL_PREDICT_FALSE(src.size() > std::numeric_limits::max() - - IntCast(start_pos()))) { + if (ABSL_PREDICT_FALSE(IntCast(pos()) > + std::numeric_limits::max() || + src.size() > std::numeric_limits::max() - + IntCast(pos()))) { return FailOverflow(); } - move_start_pos(src.size()); - uncompressed_.Append(std::move(src), options_); + const size_t first_length = UnsignedMin( + RoundUp(IntCast(pos())) - IntCast(pos()), + IntCast(src.size())); + if (first_length > 0) { + if (ABSL_PREDICT_FALSE(!Push(first_length))) return false; + std::memset(cursor(), src.fill(), first_length); + move_cursor(first_length); + src.Extract(first_length); + } + Write(src.Extract(RoundDown(IntCast(src.size())))); + const size_t last_length = IntCast(src.size()); + if (last_length > 0) { + if (ABSL_PREDICT_FALSE(!Push(last_length))) return false; + std::memset(cursor(), src.fill(), last_length); + move_cursor(last_length); + } return true; } diff --git a/riegeli/snappy/snappy_writer.h b/riegeli/snappy/snappy_writer.h index f203aab3..a72bcac0 100644 --- a/riegeli/snappy/snappy_writer.h +++ b/riegeli/snappy/snappy_writer.h @@ -110,11 +110,11 @@ class SnappyWriterBase : public Writer { void SetWriteSizeHintImpl(absl::optional write_size_hint) override; bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; bool WriteSlow(absl::Cord&& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; Reader* ReadModeImpl(Position initial_pos) override; diff --git a/riegeli/tensorflow/io/file_writer.cc b/riegeli/tensorflow/io/file_writer.cc index 0cc2140d..07fb12a1 100644 --- a/riegeli/tensorflow/io/file_writer.cc +++ b/riegeli/tensorflow/io/file_writer.cc @@ -210,6 +210,19 @@ bool FileWriterBase::WriteSlow(absl::string_view src) { return Writer::WriteSlow(src); } +bool FileWriterBase::WriteSlow(ExternalRef src) { + RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) + << "Failed precondition of Writer::WriteSlow(ExternalRef): " + "enough space available, use Write(ExternalRef) instead"; + if (src.size() >= buffer_sizer_.BufferLength(pos())) { + // Write directly from `src`. + if (ABSL_PREDICT_FALSE(!SyncBuffer())) return false; + if (ABSL_PREDICT_FALSE(!ok())) return false; + return WriteInternal(absl::Cord(std::move(src))); + } + return Writer::WriteSlow(std::move(src)); +} + bool FileWriterBase::WriteSlow(const Chain& src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(Chain): " @@ -252,19 +265,6 @@ bool FileWriterBase::WriteSlow(const absl::Cord& src) { return Writer::WriteSlow(src); } -bool FileWriterBase::WriteSlow(ExternalRef src) { - RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) - << "Failed precondition of Writer::WriteSlow(ExternalRef): " - "enough space available, use Write(ExternalRef) instead"; - if (src.size() >= buffer_sizer_.BufferLength(pos())) { - // Write directly from `src`. - if (ABSL_PREDICT_FALSE(!SyncBuffer())) return false; - if (ABSL_PREDICT_FALSE(!ok())) return false; - return WriteInternal(absl::Cord(std::move(src))); - } - return Writer::WriteSlow(std::move(src)); -} - bool FileWriterBase::WriteSlow(ByteFill src) { RIEGELI_ASSERT_LT(UnsignedMin(available(), kMaxBytesToCopy), src.size()) << "Failed precondition of Writer::WriteSlow(ByteFill): " diff --git a/riegeli/tensorflow/io/file_writer.h b/riegeli/tensorflow/io/file_writer.h index d1c82925..14b028b3 100644 --- a/riegeli/tensorflow/io/file_writer.h +++ b/riegeli/tensorflow/io/file_writer.h @@ -137,10 +137,10 @@ class FileWriterBase : public Writer { bool PushSlow(size_t min_length, size_t recommended_length) override; using Writer::WriteSlow; bool WriteSlow(absl::string_view src) override; + bool WriteSlow(ExternalRef src) override; bool WriteSlow(const Chain& src) override; bool WriteSlow(Chain&& src) override; bool WriteSlow(const absl::Cord& src) override; - bool WriteSlow(ExternalRef src) override; bool WriteSlow(ByteFill src) override; bool FlushImpl(FlushType flush_type) override; Reader* ReadModeImpl(Position initial_pos) override;