@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/strings/internal/cord_rep_consume.cc

@@ -1,64 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/strings/internal/cord_rep_consume.h"
-
-#include <array>
-#include <utility>
-
-#include "absl/container/inlined_vector.h"
-#include "absl/functional/function_ref.h"
-#include "absl/strings/internal/cord_internal.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-namespace {
-
-// Unrefs the provided `substring`, and returns `substring->child`
-// Adds or assumes a reference on `substring->child`
-CordRep* ClipSubstring(CordRepSubstring* substring) {
-  CordRep* child = substring->child;
-  if (substring->refcount.IsOne()) {
-    delete substring;
-  } else {
-    CordRep::Ref(child);
-    CordRep::Unref(substring);
-  }
-  return child;
-}
-
-}  // namespace
-
-void Consume(CordRep* rep,
-             FunctionRef<void(CordRep*, size_t, size_t)> consume_fn) {
-  size_t offset = 0;
-  size_t length = rep->length;
-
-  if (rep->tag == SUBSTRING) {
-    offset += rep->substring()->start;
-    rep = ClipSubstring(rep->substring());
-  }
-  consume_fn(rep, offset, length);
-}
-
-void ReverseConsume(CordRep* rep,
-                    FunctionRef<void(CordRep*, size_t, size_t)> consume_fn) {
-  return Consume(rep, consume_fn);
-}
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/strings/internal/cord_rep_consume.h

@@ -1,47 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_
-
-#include <functional>
-
-#include "absl/functional/function_ref.h"
-#include "absl/strings/internal/cord_internal.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// Consume() and ReverseConsume() consume CONCAT based trees and invoke the
-// provided functor with the contained nodes in the proper forward or reverse
-// order, which is used to convert CONCAT trees into other tree or cord data.
-// All CONCAT and SUBSTRING nodes are processed internally. The 'offset`
-// parameter of the functor is non-zero for any nodes below SUBSTRING nodes.
-// It's up to the caller to form these back into SUBSTRING nodes or otherwise
-// store offset / prefix information. These functions are intended to be used
-// only for migration / transitional code where due to factors such as ODR
-// violations, we can not 100% guarantee that all code respects 'new format'
-// settings and flags, so we need to be able to parse old data on the fly until
-// all old code is deprecated / no longer the default format.
-void Consume(CordRep* rep,
-             FunctionRef<void(CordRep*, size_t, size_t)> consume_fn);
-void ReverseConsume(CordRep* rep,
-                    FunctionRef<void(CordRep*, size_t, size_t)> consume_fn);
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_CONSUME_H_

package/deps/abseil-cpp/absl/strings/internal/cord_rep_crc.cc

@@ -1,56 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/strings/internal/cord_rep_crc.h"
-
-#include <cassert>
-#include <cstdint>
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/strings/internal/cord_internal.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-CordRepCrc* CordRepCrc::New(CordRep* child, crc_internal::CrcCordState state) {
-  if (child != nullptr && child->IsCrc()) {
-    if (child->refcount.IsOne()) {
-      child->crc()->crc_cord_state = std::move(state);
-      return child->crc();
-    }
-    CordRep* old = child;
-    child = old->crc()->child;
-    CordRep::Ref(child);
-    CordRep::Unref(old);
-  }
-  auto* new_cordrep = new CordRepCrc;
-  new_cordrep->length = child != nullptr ? child->length : 0;
-  new_cordrep->tag = cord_internal::CRC;
-  new_cordrep->child = child;
-  new_cordrep->crc_cord_state = std::move(state);
-  return new_cordrep;
-}
-
-void CordRepCrc::Destroy(CordRepCrc* node) {
-  if (node->child != nullptr) {
-    CordRep::Unref(node->child);
-  }
-  delete node;
-}
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/strings/internal/cord_rep_crc.h

@@ -1,103 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_
-
-#include <cassert>
-#include <cstdint>
-
-#include "absl/base/config.h"
-#include "absl/base/optimization.h"
-#include "absl/crc/internal/crc_cord_state.h"
-#include "absl/strings/internal/cord_internal.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// CordRepCrc is a CordRep node intended only to appear at the top level of a
-// cord tree.  It associates an "expected CRC" with the contained data, to allow
-// for easy passage of checksum data in Cord data flows.
-//
-// From Cord's perspective, the crc value has no semantics; any validation of
-// the contained checksum is the user's responsibility.
-struct CordRepCrc : public CordRep {
-  CordRep* child;
-  absl::crc_internal::CrcCordState crc_cord_state;
-
-  // Consumes `child` and returns a CordRepCrc prefixed tree containing `child`.
-  // If the specified `child` is itself a CordRepCrc node, then this method
-  // either replaces the existing node, or directly updates the crc state in it
-  // depending on the node being shared or not, i.e.: refcount.IsOne().
-  // `child` must only be null if the Cord is empty. Never returns null.
-  static CordRepCrc* New(CordRep* child, crc_internal::CrcCordState state);
-
-  // Destroys (deletes) the provided node. `node` must not be null.
-  static void Destroy(CordRepCrc* node);
-};
-
-// Consumes `rep` and returns a CordRep* with any outer CordRepCrc wrapper
-// removed.  This is usually a no-op (returning `rep`), but this will remove and
-// unref an outer CordRepCrc node.
-inline CordRep* RemoveCrcNode(CordRep* rep) {
-  assert(rep != nullptr);
-  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
-    CordRep* child = rep->crc()->child;
-    if (rep->refcount.IsOne()) {
-      delete rep->crc();
-    } else {
-      CordRep::Ref(child);
-      CordRep::Unref(rep);
-    }
-    return child;
-  }
-  return rep;
-}
-
-// Returns `rep` if it is not a CordRepCrc node, or its child if it is.
-// Does not consume or create a reference on `rep` or the returned value.
-inline CordRep* SkipCrcNode(CordRep* rep) {
-  assert(rep != nullptr);
-  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
-    return rep->crc()->child;
-  } else {
-    return rep;
-  }
-}
-
-inline const CordRep* SkipCrcNode(const CordRep* rep) {
-  assert(rep != nullptr);
-  if (ABSL_PREDICT_FALSE(rep->IsCrc())) {
-    return rep->crc()->child;
-  } else {
-    return rep;
-  }
-}
-
-inline CordRepCrc* CordRep::crc() {
-  assert(IsCrc());
-  return static_cast<CordRepCrc*>(this);
-}
-
-inline const CordRepCrc* CordRep::crc() const {
-  assert(IsCrc());
-  return static_cast<const CordRepCrc*>(this);
-}
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_CRC_H_

package/deps/abseil-cpp/absl/strings/internal/cord_rep_crc_test.cc

@@ -1,130 +0,0 @@
-// Copyright 2021 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/strings/internal/cord_rep_crc.h"
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/base/config.h"
-#include "absl/crc/internal/crc_cord_state.h"
-#include "absl/strings/internal/cord_internal.h"
-#include "absl/strings/internal/cord_rep_test_util.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-namespace {
-
-using ::absl::cordrep_testing::MakeFlat;
-using ::testing::Eq;
-using ::testing::IsNull;
-using ::testing::Ne;
-
-#if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST
-
-TEST(CordRepCrc, RemoveCrcWithNullptr) {
-  EXPECT_DEATH(RemoveCrcNode(nullptr), "");
-}
-
-#endif  // !NDEBUG && GTEST_HAS_DEATH_TEST
-
-absl::crc_internal::CrcCordState MakeCrcCordState(uint32_t crc) {
-  crc_internal::CrcCordState state;
-  state.mutable_rep()->prefix_crc.push_back(
-      crc_internal::CrcCordState::PrefixCrc(42, crc32c_t{crc}));
-  return state;
-}
-
-TEST(CordRepCrc, NewDestroy) {
-  CordRep* rep = cordrep_testing::MakeFlat("Hello world");
-  CordRepCrc* crc = CordRepCrc::New(rep, MakeCrcCordState(12345));
-  EXPECT_TRUE(crc->refcount.IsOne());
-  EXPECT_THAT(crc->child, Eq(rep));
-  EXPECT_THAT(crc->crc_cord_state.Checksum(), Eq(crc32c_t{12345u}));
-  EXPECT_TRUE(rep->refcount.IsOne());
-  CordRepCrc::Destroy(crc);
-}
-
-TEST(CordRepCrc, NewExistingCrcNotShared) {
-  CordRep* rep = cordrep_testing::MakeFlat("Hello world");
-  CordRepCrc* crc = CordRepCrc::New(rep, MakeCrcCordState(12345));
-  CordRepCrc* new_crc = CordRepCrc::New(crc, MakeCrcCordState(54321));
-  EXPECT_THAT(new_crc, Eq(crc));
-  EXPECT_TRUE(new_crc->refcount.IsOne());
-  EXPECT_THAT(new_crc->child, Eq(rep));
-  EXPECT_THAT(new_crc->crc_cord_state.Checksum(), Eq(crc32c_t{54321u}));
-  EXPECT_TRUE(rep->refcount.IsOne());
-  CordRepCrc::Destroy(new_crc);
-}
-
-TEST(CordRepCrc, NewExistingCrcShared) {
-  CordRep* rep = cordrep_testing::MakeFlat("Hello world");
-  CordRepCrc* crc = CordRepCrc::New(rep, MakeCrcCordState(12345));
-  CordRep::Ref(crc);
-  CordRepCrc* new_crc = CordRepCrc::New(crc, MakeCrcCordState(54321));
-
-  EXPECT_THAT(new_crc, Ne(crc));
-  EXPECT_TRUE(new_crc->refcount.IsOne());
-  EXPECT_TRUE(crc->refcount.IsOne());
-  EXPECT_FALSE(rep->refcount.IsOne());
-  EXPECT_THAT(crc->child, Eq(rep));
-  EXPECT_THAT(new_crc->child, Eq(rep));
-  EXPECT_THAT(crc->crc_cord_state.Checksum(), Eq(crc32c_t{12345u}));
-  EXPECT_THAT(new_crc->crc_cord_state.Checksum(), Eq(crc32c_t{54321u}));
-
-  CordRep::Unref(crc);
-  CordRep::Unref(new_crc);
-}
-
-TEST(CordRepCrc, NewEmpty) {
-  CordRepCrc* crc = CordRepCrc::New(nullptr, MakeCrcCordState(12345));
-  EXPECT_TRUE(crc->refcount.IsOne());
-  EXPECT_THAT(crc->child, IsNull());
-  EXPECT_THAT(crc->length, Eq(0u));
-  EXPECT_THAT(crc->crc_cord_state.Checksum(), Eq(crc32c_t{12345u}));
-  EXPECT_TRUE(crc->refcount.IsOne());
-  CordRepCrc::Destroy(crc);
-}
-
-TEST(CordRepCrc, RemoveCrcNotCrc) {
-  CordRep* rep = cordrep_testing::MakeFlat("Hello world");
-  CordRep* nocrc = RemoveCrcNode(rep);
-  EXPECT_THAT(nocrc, Eq(rep));
-  CordRep::Unref(nocrc);
-}
-
-TEST(CordRepCrc, RemoveCrcNotShared) {
-  CordRep* rep = cordrep_testing::MakeFlat("Hello world");
-  CordRepCrc* crc = CordRepCrc::New(rep, MakeCrcCordState(12345));
-  CordRep* nocrc = RemoveCrcNode(crc);
-  EXPECT_THAT(nocrc, Eq(rep));
-  EXPECT_TRUE(rep->refcount.IsOne());
-  CordRep::Unref(nocrc);
-}
-
-TEST(CordRepCrc, RemoveCrcShared) {
-  CordRep* rep = cordrep_testing::MakeFlat("Hello world");
-  CordRepCrc* crc = CordRepCrc::New(rep, MakeCrcCordState(12345));
-  CordRep::Ref(crc);
-  CordRep* nocrc = RemoveCrcNode(crc);
-  EXPECT_THAT(nocrc, Eq(rep));
-  EXPECT_FALSE(rep->refcount.IsOne());
-  CordRep::Unref(nocrc);
-  CordRep::Unref(crc);
-}
-
-}  // namespace
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/strings/internal/cord_rep_flat.h

@@ -1,195 +0,0 @@
-// Copyright 2020 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
-#define ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_
-
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-
-#include "absl/base/config.h"
-#include "absl/base/macros.h"
-#include "absl/strings/internal/cord_internal.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace cord_internal {
-
-// Note: all constants below are never ODR used and internal to cord, we define
-// these as static constexpr to avoid 'in struct' definition and usage clutter.
-
-// Largest and smallest flat node lengths we are willing to allocate
-// Flat allocation size is stored in tag, which currently can encode sizes up
-// to 4K, encoded as multiple of either 8 or 32 bytes.
-// If we allow for larger sizes, we need to change this to 8/64, 16/128, etc.
-// kMinFlatSize is bounded by tag needing to be at least FLAT * 8 bytes, and
-// ideally a 'nice' size aligning with allocation and cacheline sizes like 32.
-// kMaxFlatSize is bounded by the size resulting in a computed tag no greater
-// than MAX_FLAT_TAG. MAX_FLAT_TAG provides for additional 'high' tag values.
-static constexpr size_t kFlatOverhead = offsetof(CordRep, storage);
-static constexpr size_t kMinFlatSize = 32;
-static constexpr size_t kMaxFlatSize = 4096;
-static constexpr size_t kMaxFlatLength = kMaxFlatSize - kFlatOverhead;
-static constexpr size_t kMinFlatLength = kMinFlatSize - kFlatOverhead;
-static constexpr size_t kMaxLargeFlatSize = 256 * 1024;
-static constexpr size_t kMaxLargeFlatLength = kMaxLargeFlatSize - kFlatOverhead;
-
-// kTagBase should make the Size <--> Tag computation resilient
-// against changes to the value of FLAT when we add a new tag..
-static constexpr uint8_t kTagBase = FLAT - 4;
-
-// Converts the provided rounded size to the corresponding tag
-constexpr uint8_t AllocatedSizeToTagUnchecked(size_t size) {
-  return static_cast<uint8_t>(size <= 512 ? kTagBase + size / 8
-                              : size <= 8192
-                                  ? kTagBase + 512 / 8 + size / 64 - 512 / 64
-                                  : kTagBase + 512 / 8 + ((8192 - 512) / 64) +
-                                        size / 4096 - 8192 / 4096);
-}
-
-// Converts the provided tag to the corresponding allocated size
-constexpr size_t TagToAllocatedSize(uint8_t tag) {
-  return (tag <= kTagBase + 512 / 8) ? tag * 8 - kTagBase * 8
-         : (tag <= kTagBase + (512 / 8) + ((8192 - 512) / 64))
-             ? 512 + tag * 64 - kTagBase * 64 - 512 / 8 * 64
-             : 8192 + tag * 4096 - kTagBase * 4096 -
-                   ((512 / 8) + ((8192 - 512) / 64)) * 4096;
-}
-
-static_assert(AllocatedSizeToTagUnchecked(kMinFlatSize) == FLAT, "");
-static_assert(AllocatedSizeToTagUnchecked(kMaxLargeFlatSize) == MAX_FLAT_TAG,
-              "");
-
-// RoundUp logically performs `((n + m - 1) / m) * m` to round up to the nearest
-// multiple of `m`, optimized for the invariant that `m` is a power of 2.
-constexpr size_t RoundUp(size_t n, size_t m) {
-  return (n + m - 1) & (0 - m);
-}
-
-// Returns the size to the nearest equal or larger value that can be
-// expressed exactly as a tag value.
-inline size_t RoundUpForTag(size_t size) {
-  return RoundUp(size, (size <= 512) ? 8 : (size <= 8192 ? 64 : 4096));
-}
-
-// Converts the allocated size to a tag, rounding down if the size
-// does not exactly match a 'tag expressible' size value. The result is
-// undefined if the size exceeds the maximum size that can be encoded in
-// a tag, i.e., if size is larger than TagToAllocatedSize(<max tag>).
-inline uint8_t AllocatedSizeToTag(size_t size) {
-  const uint8_t tag = AllocatedSizeToTagUnchecked(size);
-  assert(tag <= MAX_FLAT_TAG);
-  return tag;
-}
-
-// Converts the provided tag to the corresponding available data length
-constexpr size_t TagToLength(uint8_t tag) {
-  return TagToAllocatedSize(tag) - kFlatOverhead;
-}
-
-// Enforce that kMaxFlatSize maps to a well-known exact tag value.
-static_assert(TagToAllocatedSize(MAX_FLAT_TAG) == kMaxLargeFlatSize,
-              "Bad tag logic");
-
-struct CordRepFlat : public CordRep {
-  // Tag for explicit 'large flat' allocation
-  struct Large {};
-
-  // Creates a new flat node.
-  template <size_t max_flat_size, typename... Args>
-  static CordRepFlat* NewImpl(size_t len, Args... args ABSL_ATTRIBUTE_UNUSED) {
-    if (len <= kMinFlatLength) {
-      len = kMinFlatLength;
-    } else if (len > max_flat_size - kFlatOverhead) {
-      len = max_flat_size - kFlatOverhead;
-    }
-
-    // Round size up so it matches a size we can exactly express in a tag.
-    const size_t size = RoundUpForTag(len + kFlatOverhead);
-    void* const raw_rep = ::operator new(size);
-    // GCC 13 has a false-positive -Wstringop-overflow warning here.
-    #if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(13, 0)
-    #pragma GCC diagnostic push
-    #pragma GCC diagnostic ignored "-Wstringop-overflow"
-    #endif
-    CordRepFlat* rep = new (raw_rep) CordRepFlat();
-    rep->tag = AllocatedSizeToTag(size);
-    #if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(13, 0)
-    #pragma GCC diagnostic pop
-    #endif
-    return rep;
-  }
-
-  static CordRepFlat* New(size_t len) { return NewImpl<kMaxFlatSize>(len); }
-
-  static CordRepFlat* New(Large, size_t len) {
-    return NewImpl<kMaxLargeFlatSize>(len);
-  }
-
-  // Deletes a CordRepFlat instance created previously through a call to New().
-  // Flat CordReps are allocated and constructed with raw ::operator new and
-  // placement new, and must be destructed and deallocated accordingly.
-  static void Delete(CordRep*rep) {
-    assert(rep->tag >= FLAT && rep->tag <= MAX_FLAT_TAG);
-
-#if defined(__cpp_sized_deallocation)
-    size_t size = TagToAllocatedSize(rep->tag);
-    rep->~CordRep();
-    ::operator delete(rep, size);
-#else
-    rep->~CordRep();
-    ::operator delete(rep);
-#endif
-  }
-
-  // Create a CordRepFlat containing `data`, with an optional additional
-  // extra capacity of up to `extra` bytes. Requires that `data.size()`
-  // is less than kMaxFlatLength.
-  static CordRepFlat* Create(absl::string_view data, size_t extra = 0) {
-    assert(data.size() <= kMaxFlatLength);
-    CordRepFlat* flat = New(data.size() + (std::min)(extra, kMaxFlatLength));
-    memcpy(flat->Data(), data.data(), data.size());
-    flat->length = data.size();
-    return flat;
-  }
-
-  // Returns a pointer to the data inside this flat rep.
-  char* Data() { return reinterpret_cast<char*>(storage); }
-  const char* Data() const { return reinterpret_cast<const char*>(storage); }
-
-  // Returns the maximum capacity (payload size) of this instance.
-  size_t Capacity() const { return TagToLength(tag); }
-
-  // Returns the allocated size (payload + overhead) of this instance.
-  size_t AllocatedSize() const { return TagToAllocatedSize(tag); }
-};
-
-// Now that CordRepFlat is defined, we can define CordRep's helper casts:
-inline CordRepFlat* CordRep::flat() {
-  assert(tag >= FLAT && tag <= MAX_FLAT_TAG);
-  return reinterpret_cast<CordRepFlat*>(this);
-}
-
-inline const CordRepFlat* CordRep::flat() const {
-  assert(tag >= FLAT && tag <= MAX_FLAT_TAG);
-  return reinterpret_cast<const CordRepFlat*>(this);
-}
-
-}  // namespace cord_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_STRINGS_INTERNAL_CORD_REP_FLAT_H_