folly::fbstring_core< Char > Class Template Reference

#include <FBString.h>

Classes
struct	MediumLarge
struct	RefCounted

Public Member Functions
	fbstring_core () noexcept
	fbstring_core (const fbstring_core &rhs)
	fbstring_core (fbstring_core &&goner) noexcept
	fbstring_core (const Char *const data, const size_t size, bool disableSSO=false)
	~fbstring_core () noexcept
	fbstring_core (Char *const data, const size_t size, const size_t allocatedSize, AcquireMallocatedString)
void	swap (fbstring_core &rhs)
const Char *	data () const
Char *	mutableData ()
const Char *	c_str () const
void	shrink (const size_t delta)
FOLLY_MALLOC_NOINLINE void	reserve (size_t minCapacity, bool disableSSO=false)
Char *	expandNoinit (const size_t delta, bool expGrowth=false, bool disableSSO=false)
void	push_back (Char c)
size_t	size () const
size_t	capacity () const
bool	isShared () const

Static Protected Attributes
static constexpr auto	kIsLittleEndian

Private Types
enum	Category : category_type { Category::isSmall = 0, Category::isMedium = kIsLittleEndian ? 0x80 : 0x2, Category::isLarge = kIsLittleEndian ? 0x40 : 0x1 }
typedef uint8_t	category_type

Private Member Functions
fbstring_core &	operator= (const fbstring_core &rhs)
void	reset ()
FOLLY_MALLOC_NOINLINE void	destroyMediumLarge () noexcept
Category	category () const
size_t	smallSize () const
void	setSmallSize (size_t s)
void	copySmall (const fbstring_core &)
void	copyMedium (const fbstring_core &)
void	copyLarge (const fbstring_core &)
void	initSmall (const Char *data, size_t size)
void	initMedium (const Char *data, size_t size)
void	initLarge (const Char *data, size_t size)
void	reserveSmall (size_t minCapacity, bool disableSSO)
void	reserveMedium (size_t minCapacity)
void	reserveLarge (size_t minCapacity)
void	shrinkSmall (size_t delta)
void	shrinkMedium (size_t delta)
void	shrinkLarge (size_t delta)
void	unshare (size_t minCapacity=0)
Char *	mutableDataLarge ()

Private Attributes
union {
uint8_t   bytes_ [sizeof(MediumLarge)]
Char   small_ [sizeof(MediumLarge)/sizeof(Char)]
MediumLarge   ml_
};

Static Private Attributes
static constexpr size_t	lastChar = sizeof(MediumLarge) - 1
static constexpr size_t	maxSmallSize = lastChar / sizeof(Char)
static constexpr size_t	maxMediumSize = 254 / sizeof(Char)
static constexpr uint8_t	categoryExtractMask = kIsLittleEndian ? 0xC0 : 0x3
static constexpr size_t	kCategoryShift = (sizeof(size_t) - 1) * 8
static constexpr size_t	capacityExtractMask

Detailed Description

template<class Char>
class folly::fbstring_core< Char >

This is the core of the string. The code should work on 32- and 64-bit and both big- and little-endianan architectures with any Char size.

The storage is selected as follows (assuming we store one-byte characters on a 64-bit machine): (a) "small" strings between 0 and 23 chars are stored in-situ without allocation (the rightmost byte stores the size); (b) "medium" strings from 24 through 254 chars are stored in malloc-allocated memory that is copied eagerly; (c) "large" strings of 255 chars and above are stored in a similar structure as medium arrays, except that the string is reference-counted and copied lazily. the reference count is allocated right before the character array.

The discriminator between these three strategies sits in two bits of the rightmost char of the storage:

• If neither is set, then the string is small. Its length is represented by the lower-order bits on little-endian or the high-order bits on big-endian of that rightmost character. The value of these six bits is maxSmallSize - size, so this quantity must be subtracted from maxSmallSize to compute the size of the string (see smallSize()). This scheme ensures that when size ==maxSmallSize`, the last byte in the storage is \0. This way, storage will be a null-terminated sequence of bytes, even if all 23 bytes of data are used on a 64-bit architecture. This enables c_str() and data() to simply return a pointer to the storage.
• If the MSb is set, the string is medium width.
• If the second MSb is set, then the string is large. On little-endian, these 2 bits are the 2 MSbs of MediumLarge::capacity_, while on big-endian, these 2 bits are the 2 LSbs. This keeps both little-endian and big-endian fbstring_core equivalent with merely different ops used to extract capacity/category.

Definition at line 327 of file FBString.h.

Member Typedef Documentation

template<class Char>

typedef uint8_t folly::fbstring_core< Char >::category_type

private

Definition at line 619 of file FBString.h.

Member Enumeration Documentation

template<class Char>

enum folly::fbstring_core::Category : category_type

strongprivate

Enumerator
isSmall
isMedium
isLarge

Definition at line 621 of file FBString.h.

                      : category_type {
    isSmall = 0,
    isMedium = kIsLittleEndian ? 0x80 : 0x2,
    isLarge = kIsLittleEndian ? 0x40 : 0x1,
  };

Constructor & Destructor Documentation

template<class Char>

folly::fbstring_core< Char >::fbstring_core ( )

inlinenoexcept

Definition at line 341 of file FBString.h.

                           {
    reset();
  }

template<class Char>

folly::fbstring_core< Char >::fbstring_core ( const fbstring_core< Char > &  rhs )

inline

Definition at line 345 of file FBString.h.

                                          {
    FBSTRING_ASSERT(&rhs != this);
    switch (rhs.category()) {
      case Category::isSmall:
        copySmall(rhs);
        break;
      case Category::isMedium:
        copyMedium(rhs);
        break;
      case Category::isLarge:
        copyLarge(rhs);
        break;
      default:
        fbstring_detail::assume_unreachable();
    }
    FBSTRING_ASSERT(size() == rhs.size());
    FBSTRING_ASSERT(memcmp(data(), rhs.data(), size() * sizeof(Char)) == 0);
  }

template<class Char>

folly::fbstring_core< Char >::fbstring_core ( fbstring_core< Char > &&  goner )

inlinenoexcept

Definition at line 364 of file FBString.h.

                                                {
    // Take goner's guts
    ml_ = goner.ml_;
    // Clean goner's carcass
    goner.reset();
  }

template<class Char>

folly::fbstring_core< Char >::fbstring_core ( const Char *const  data, const size_t  size, bool  disableSSO = false  )

inline

Definition at line 371 of file FBString.h.

                                              {
    if (!disableSSO && size <= maxSmallSize) {
      initSmall(data, size);
    } else if (size <= maxMediumSize) {
      initMedium(data, size);
    } else {
      initLarge(data, size);
    }
    FBSTRING_ASSERT(this->size() == size);
    FBSTRING_ASSERT(
        size == 0 || memcmp(this->data(), data, size * sizeof(Char)) == 0);
  }

template<class Char>

folly::fbstring_core< Char >::~fbstring_core ( )

inlinenoexcept

Definition at line 387 of file FBString.h.

                            {
    if (category() == Category::isSmall) {
      return;
    }
    destroyMediumLarge();
  }

template<class Char>

folly::fbstring_core< Char >::fbstring_core ( Char *const  data, const size_t  size, const size_t  allocatedSize, AcquireMallocatedString    )

inline

Definition at line 401 of file FBString.h.

                               {
    if (size > 0) {
      FBSTRING_ASSERT(allocatedSize >= size + 1);
      FBSTRING_ASSERT(data[size] == '\0');
      // Use the medium string storage
      ml_.data_ = data;
      ml_.size_ = size;
      // Don't forget about null terminator
      ml_.setCapacity(allocatedSize - 1, Category::isMedium);
    } else {
      // No need for the memory
      free(data);
      reset();
    }
  }

Member Function Documentation

template<class Char>

const Char* folly::fbstring_core< Char >::c_str ( ) const

inline

Definition at line 448 of file FBString.h.

                            {
    const Char* ptr = ml_.data_;
    // With this syntax, GCC and Clang generate a CMOV instead of a branch.
    ptr = (category() == Category::isSmall) ? small_ : ptr;
    return ptr;
  }

template<class Char>

size_t folly::fbstring_core< Char >::capacity ( ) const

inline

Definition at line 509 of file FBString.h.

Referenced by folly::operator+().

                          {
    switch (category()) {
      case Category::isSmall:
        return maxSmallSize;
      case Category::isLarge:
        // For large-sized strings, a multi-referenced chunk has no
        // available capacity. This is because any attempt to append
        // data would trigger a new allocation.
        if (RefCounted::refs(ml_.data_) > 1) {
          return ml_.size_;
        }
        break;
      default:
        break;
    }
    return ml_.capacity();
  }

template<class Char>

Category folly::fbstring_core< Char >::category ( ) const

inlineprivate

Definition at line 627 of file FBString.h.

Referenced by folly::fbstring_core< char >::fbstring_core().

                            {
    // works for both big-endian and little-endian
    return static_cast<Category>(bytes_[lastChar] & categoryExtractMask);
  }

template<class Char >

FOLLY_MALLOC_NOINLINE void folly::fbstring_core< Char >::copyLarge ( const fbstring_core< Char > &  rhs )

inlineprivate

Definition at line 741 of file FBString.h.

References FBSTRING_ASSERT, folly::fbstring_core< Char >::ml_, folly::size(), and folly::fbstring_core< Char >::size().

                              {
  // Large strings are just refcounted
  ml_ = rhs.ml_;
  RefCounted::incrementRefs(ml_.data_);
  FBSTRING_ASSERT(category() == Category::isLarge && size() == rhs.size());
}

template<class Char >

FOLLY_MALLOC_NOINLINE void folly::fbstring_core< Char >::copyMedium ( const fbstring_core< Char > &  rhs )

inlineprivate

Definition at line 726 of file FBString.h.

References testing::gmock_generated_actions_test::Char(), folly::checkedMalloc(), folly::fbstring_core< Char >::MediumLarge::data_, FBSTRING_ASSERT, folly::goodMallocSize(), folly::fbstring_core< Char >::ml_, folly::fbstring_detail::podCopy(), and folly::fbstring_core< Char >::MediumLarge::size_.

                              {
  // Medium strings are copied eagerly. Don't forget to allocate
  // one extra Char for the null terminator.
  auto const allocSize = goodMallocSize((1 + rhs.ml_.size_) * sizeof(Char));
  ml_.data_ = static_cast<Char*>(checkedMalloc(allocSize));
  // Also copies terminator.
  fbstring_detail::podCopy(
      rhs.ml_.data_, rhs.ml_.data_ + rhs.ml_.size_ + 1, ml_.data_);
  ml_.size_ = rhs.ml_.size_;
  ml_.setCapacity(allocSize / sizeof(Char) - 1, Category::isMedium);
  FBSTRING_ASSERT(category() == Category::isMedium);
}

template<class Char >

void folly::fbstring_core< Char >::copySmall ( const fbstring_core< Char > &  rhs )

inlineprivate

Definition at line 707 of file FBString.h.

References data_, FBSTRING_ASSERT, folly::fbstring_core< Char >::ml_, folly::size(), and folly::fbstring_core< Char >::size().

                                                                   {
  static_assert(offsetof(MediumLarge, data_) == 0, "fbstring layout failure");
  static_assert(
      offsetof(MediumLarge, size_) == sizeof(ml_.data_),
      "fbstring layout failure");
  static_assert(
      offsetof(MediumLarge, capacity_) == 2 * sizeof(ml_.data_),
      "fbstring layout failure");
  // Just write the whole thing, don't look at details. In
  // particular we need to copy capacity anyway because we want
  // to set the size (don't forget that the last character,
  // which stores a short string's length, is shared with the
  // ml_.capacity field).
  ml_ = rhs.ml_;
  FBSTRING_ASSERT(
      category() == Category::isSmall && this->size() == rhs.size());
}

template<class Char>

const Char* folly::fbstring_core< Char >::data ( ) const

inline

Definition at line 432 of file FBString.h.

Referenced by folly::fbstring_core< char >::fbstring_core().

                           {
    return c_str();
  }

template<class Char>

FOLLY_MALLOC_NOINLINE void folly::fbstring_core< Char >::destroyMediumLarge ( )

inlineprivatenoexcept

Definition at line 539 of file FBString.h.

                                                           {
    auto const c = category();
    FBSTRING_ASSERT(c != Category::isSmall);
    if (c == Category::isMedium) {
      free(ml_.data_);
    } else {
      RefCounted::decrementRefs(ml_.data_);
    }
  }

template<class Char >

Char * folly::fbstring_core< Char >::expandNoinit ( const size_t  delta, bool  expGrowth = false, bool  disableSSO = false  )

inline

Definition at line 943 of file FBString.h.

References FBSTRING_ASSERT, FBSTRING_LIKELY, FBSTRING_UNLIKELY, max, reserve(), and folly::size().

                       {
  // Strategy is simple: make room, then change size
  FBSTRING_ASSERT(capacity() >= size());
  size_t sz, newSz;
  if (category() == Category::isSmall) {
    sz = smallSize();
    newSz = sz + delta;
    if (!disableSSO && FBSTRING_LIKELY(newSz <= maxSmallSize)) {
      setSmallSize(newSz);
      return small_ + sz;
    }
    reserveSmall(
        expGrowth ? std::max(newSz, 2 * maxSmallSize) : newSz, disableSSO);
  } else {
    sz = ml_.size_;
    newSz = sz + delta;
    if (FBSTRING_UNLIKELY(newSz > capacity())) {
      // ensures not shared
      reserve(expGrowth ? std::max(newSz, 1 + capacity() * 3 / 2) : newSz);
    }
  }
  FBSTRING_ASSERT(capacity() >= newSz);
  // Category can't be small - we took care of that above
  FBSTRING_ASSERT(
      category() == Category::isMedium || category() == Category::isLarge);
  ml_.size_ = newSz;
  ml_.data_[newSz] = '\0';
  FBSTRING_ASSERT(size() == newSz);
  return ml_.data_ + sz;
}

template<class Char>

FOLLY_MALLOC_NOINLINE void folly::fbstring_core< Char >::initLarge ( const Char *  data, size_t  size  )

inlineprivate

Definition at line 814 of file FBString.h.

References folly::size().

                       {
  // Large strings are allocated differently
  size_t effectiveCapacity = size;
  auto const newRC = RefCounted::create(data, &effectiveCapacity);
  ml_.data_ = newRC->data_;
  ml_.size_ = size;
  ml_.setCapacity(effectiveCapacity, Category::isLarge);
  ml_.data_[size] = '\0';
}

template<class Char>

FOLLY_MALLOC_NOINLINE void folly::fbstring_core< Char >::initMedium ( const Char *  data, size_t  size  )

inlineprivate

Definition at line 798 of file FBString.h.

References testing::gmock_generated_actions_test::Char(), folly::checkedMalloc(), FBSTRING_LIKELY, folly::goodMallocSize(), folly::fbstring_detail::podCopy(), and folly::size().

                       {
  // Medium strings are allocated normally. Don't forget to
  // allocate one extra Char for the terminating null.
  auto const allocSize = goodMallocSize((1 + size) * sizeof(Char));
  ml_.data_ = static_cast<Char*>(checkedMalloc(allocSize));
  if (FBSTRING_LIKELY(size > 0)) {
    fbstring_detail::podCopy(data, data + size, ml_.data_);
  }
  ml_.size_ = size;
  ml_.setCapacity(allocSize / sizeof(Char) - 1, Category::isMedium);
  ml_.data_[size] = '\0';
}

template<class Char>

void folly::fbstring_core< Char >::initSmall ( const Char *  data, size_t  size  )

inlineprivate

Definition at line 751 of file FBString.h.

References testing::gmock_generated_actions_test::Char(), data, FOLLY_FALLTHROUGH, and folly::fbstring_detail::podCopy().

                       {
  // Layout is: Char* data_, size_t size_, size_t capacity_
  static_assert(
      sizeof(*this) == sizeof(Char*) + 2 * sizeof(size_t),
      "fbstring has unexpected size");
  static_assert(
      sizeof(Char*) == sizeof(size_t), "fbstring size assumption violation");
  // sizeof(size_t) must be a power of 2
  static_assert(
      (sizeof(size_t) & (sizeof(size_t) - 1)) == 0,
      "fbstring size assumption violation");

// If data is aligned, use fast word-wise copying. Otherwise,
// use conservative memcpy.
// The word-wise path reads bytes which are outside the range of
// the string, and makes ASan unhappy, so we disable it when
// compiling with ASan.
#ifndef FBSTRING_SANITIZE_ADDRESS
  if ((reinterpret_cast<size_t>(data) & (sizeof(size_t) - 1)) == 0) {
    const size_t byteSize = size * sizeof(Char);
    constexpr size_t wordWidth = sizeof(size_t);
    switch ((byteSize + wordWidth - 1) / wordWidth) { // Number of words.
      case 3:
        ml_.capacity_ = reinterpret_cast<const size_t*>(data)[2];
        FOLLY_FALLTHROUGH;
      case 2:
        ml_.size_ = reinterpret_cast<const size_t*>(data)[1];
        FOLLY_FALLTHROUGH;
      case 1:
        ml_.data_ = *reinterpret_cast<Char**>(const_cast<Char*>(data));
        FOLLY_FALLTHROUGH;
      case 0:
        break;
    }
  } else
#endif
  {
    if (size != 0) {
      fbstring_detail::podCopy(data, data + size, small_);
    }
  }
  setSmallSize(size);
}

template<class Char>

bool folly::fbstring_core< Char >::isShared ( ) const

inline

Definition at line 527 of file FBString.h.

                        {
    return category() == Category::isLarge && RefCounted::refs(ml_.data_) > 1;
  }

template<class Char>

Char* folly::fbstring_core< Char >::mutableData ( )

inline

Definition at line 436 of file FBString.h.

                      {
    switch (category()) {
      case Category::isSmall:
        return small_;
      case Category::isMedium:
        return ml_.data_;
      case Category::isLarge:
        return mutableDataLarge();
    }
    fbstring_detail::assume_unreachable();
  }

template<class Char >

Char * folly::fbstring_core< Char >::mutableDataLarge ( )

inlineprivate

Definition at line 844 of file FBString.h.

References FBSTRING_ASSERT, and refs.

                                                   {
  FBSTRING_ASSERT(category() == Category::isLarge);
  if (RefCounted::refs(ml_.data_) > 1) { // Ensure unique.
    unshare();
  }
  return ml_.data_;
}

template<class Char>

fbstring_core& folly::fbstring_core< Char >::operator= ( const fbstring_core< Char > &  rhs )

private

template<class Char>

void folly::fbstring_core< Char >::push_back ( Char  c )

inline

Definition at line 489 of file FBString.h.

                         {
    *expandNoinit(1, /* expGrowth = */ true) = c;
  }

template<class Char>

FOLLY_MALLOC_NOINLINE void folly::fbstring_core< Char >::reserve ( size_t  minCapacity, bool  disableSSO = false  )

inline

Definition at line 467 of file FBString.h.

Referenced by folly::fbstring_core< Char >::reserveMedium().

                                                                           {
    switch (category()) {
      case Category::isSmall:
        reserveSmall(minCapacity, disableSSO);
        break;
      case Category::isMedium:
        reserveMedium(minCapacity);
        break;
      case Category::isLarge:
        reserveLarge(minCapacity);
        break;
      default:
        fbstring_detail::assume_unreachable();
    }
    FBSTRING_ASSERT(capacity() >= minCapacity);
  }

template<class Char >

FOLLY_MALLOC_NOINLINE void folly::fbstring_core< Char >::reserveLarge ( size_t  minCapacity )

inlineprivate

Definition at line 853 of file FBString.h.

References FBSTRING_ASSERT, and refs.

                        {
  FBSTRING_ASSERT(category() == Category::isLarge);
  if (RefCounted::refs(ml_.data_) > 1) { // Ensure unique
    // We must make it unique regardless; in-place reallocation is
    // useless if the string is shared. In order to not surprise
    // people, reserve the new block at current capacity or
    // more. That way, a string's capacity never shrinks after a
    // call to reserve.
    unshare(minCapacity);
  } else {
    // String is not shared, so let's try to realloc (if needed)
    if (minCapacity > ml_.capacity()) {
      // Asking for more memory
      auto const newRC = RefCounted::reallocate(
          ml_.data_, ml_.size_, ml_.capacity(), &minCapacity);
      ml_.data_ = newRC->data_;
      ml_.setCapacity(minCapacity, Category::isLarge);
    }
    FBSTRING_ASSERT(capacity() >= minCapacity);
  }
}

template<class Char >

FOLLY_MALLOC_NOINLINE void folly::fbstring_core< Char >::reserveMedium ( size_t  minCapacity )

inlineprivate

Definition at line 877 of file FBString.h.

References testing::gmock_generated_actions_test::Char(), folly::fbstring_core< Char >::MediumLarge::data_, FBSTRING_ASSERT, folly::goodMallocSize(), folly::fbstring_core< Char >::ml_, folly::fbstring_detail::podCopy(), folly::fbstring_core< Char >::reserve(), folly::fbstring_core< Char >::MediumLarge::size_, folly::smartRealloc(), and folly::fbstring_core< Char >::swap().

                              {
  FBSTRING_ASSERT(category() == Category::isMedium);
  // String is not shared
  if (minCapacity <= ml_.capacity()) {
    return; // nothing to do, there's enough room
  }
  if (minCapacity <= maxMediumSize) {
    // Keep the string at medium size. Don't forget to allocate
    // one extra Char for the terminating null.
    size_t capacityBytes = goodMallocSize((1 + minCapacity) * sizeof(Char));
    // Also copies terminator.
    ml_.data_ = static_cast<Char*>(smartRealloc(
        ml_.data_,
        (ml_.size_ + 1) * sizeof(Char),
        (ml_.capacity() + 1) * sizeof(Char),
        capacityBytes));
    ml_.setCapacity(capacityBytes / sizeof(Char) - 1, Category::isMedium);
  } else {
    // Conversion from medium to large string
    fbstring_core nascent;
    // Will recurse to another branch of this function
    nascent.reserve(minCapacity);
    nascent.ml_.size_ = ml_.size_;
    // Also copies terminator.
    fbstring_detail::podCopy(
        ml_.data_, ml_.data_ + ml_.size_ + 1, nascent.ml_.data_);
    nascent.swap(*this);
    FBSTRING_ASSERT(capacity() >= minCapacity);
  }
}

template<class Char >

FOLLY_MALLOC_NOINLINE void folly::fbstring_core< Char >::reserveSmall ( size_t  minCapacity, bool  disableSSO  )

inlineprivate

Definition at line 910 of file FBString.h.

References testing::gmock_generated_actions_test::Char(), folly::checkedMalloc(), FBSTRING_ASSERT, folly::goodMallocSize(), folly::fbstring_detail::podCopy(), and folly::size().

                           {
  FBSTRING_ASSERT(category() == Category::isSmall);
  if (!disableSSO && minCapacity <= maxSmallSize) {
    // small
    // Nothing to do, everything stays put
  } else if (minCapacity <= maxMediumSize) {
    // medium
    // Don't forget to allocate one extra Char for the terminating null
    auto const allocSizeBytes =
        goodMallocSize((1 + minCapacity) * sizeof(Char));
    auto const pData = static_cast<Char*>(checkedMalloc(allocSizeBytes));
    auto const size = smallSize();
    // Also copies terminator.
    fbstring_detail::podCopy(small_, small_ + size + 1, pData);
    ml_.data_ = pData;
    ml_.size_ = size;
    ml_.setCapacity(allocSizeBytes / sizeof(Char) - 1, Category::isMedium);
  } else {
    // large
    auto const newRC = RefCounted::create(&minCapacity);
    auto const size = smallSize();
    // Also copies terminator.
    fbstring_detail::podCopy(small_, small_ + size + 1, newRC->data_);
    ml_.data_ = newRC->data_;
    ml_.size_ = size;
    ml_.setCapacity(minCapacity, Category::isLarge);
    FBSTRING_ASSERT(capacity() >= minCapacity);
  }
}

template<class Char>

void folly::fbstring_core< Char >::reset ( )

inlineprivate

Definition at line 535 of file FBString.h.

               {
    setSmallSize(0);
  }

template<class Char>

void folly::fbstring_core< Char >::setSmallSize ( size_t  s )

inlineprivate

Definition at line 675 of file FBString.h.

                              {
    // Warning: this should work with uninitialized strings too,
    // so don't assume anything about the previous value of
    // small_[maxSmallSize].
    FBSTRING_ASSERT(s <= maxSmallSize);
    constexpr auto shift = kIsLittleEndian ? 0 : 2;
    small_[maxSmallSize] = char((maxSmallSize - s) << shift);
    small_[s] = '\0';
    FBSTRING_ASSERT(category() == Category::isSmall && size() == s);
  }

template<class Char>

void folly::fbstring_core< Char >::shrink ( const size_t  delta )

inline

Definition at line 455 of file FBString.h.

                                  {
    if (category() == Category::isSmall) {
      shrinkSmall(delta);
    } else if (
        category() == Category::isMedium || RefCounted::refs(ml_.data_) == 1) {
      shrinkMedium(delta);
    } else {
      shrinkLarge(delta);
    }
  }

template<class Char >

void folly::fbstring_core< Char >::shrinkLarge ( size_t  delta )

inlineprivate

Definition at line 994 of file FBString.h.

References FBSTRING_ASSERT, and folly::fbstring_core< Char >::swap().

                                                               {
  FBSTRING_ASSERT(ml_.size_ >= delta);
  // Shared large string, must make unique. This is because of the
  // durn terminator must be written, which may trample the shared
  // data.
  if (delta) {
    fbstring_core(ml_.data_, ml_.size_ - delta).swap(*this);
  }
  // No need to write the terminator.
}

template<class Char >

void folly::fbstring_core< Char >::shrinkMedium ( size_t  delta )

inlineprivate

Definition at line 985 of file FBString.h.

References FBSTRING_ASSERT.

                                                                {
  // Medium strings and unique large strings need no special
  // handling.
  FBSTRING_ASSERT(ml_.size_ >= delta);
  ml_.size_ -= delta;
  ml_.data_[ml_.size_] = '\0';
}

template<class Char >

void folly::fbstring_core< Char >::shrinkSmall ( size_t  delta )

inlineprivate

Definition at line 978 of file FBString.h.

References FBSTRING_ASSERT.

                                                               {
  // Check for underflow
  FBSTRING_ASSERT(delta <= smallSize());
  setSmallSize(smallSize() - delta);
}

template<class Char>

size_t folly::fbstring_core< Char >::size ( ) const

inline

Definition at line 493 of file FBString.h.

Referenced by folly::fbstring_core< Char >::copyLarge(), folly::fbstring_core< Char >::copySmall(), folly::fbstring_core< char >::fbstring_core(), and folly::operator+().

                      {
    size_t ret = ml_.size_;
    if /* constexpr */ (kIsLittleEndian) {
      // We can save a couple instructions, because the category is
      // small iff the last char, as unsigned, is <= maxSmallSize.
      typedef typename std::make_unsigned<Char>::type UChar;
      auto maybeSmallSize = size_t(maxSmallSize) -
          size_t(static_cast<UChar>(small_[maxSmallSize]));
      // With this syntax, GCC and Clang generate a CMOV instead of a branch.
      ret = (static_cast<ssize_t>(maybeSmallSize) >= 0) ? maybeSmallSize : ret;
    } else {
      ret = (category() == Category::isSmall) ? smallSize() : ret;
    }
    return ret;
  }

template<class Char>

size_t folly::fbstring_core< Char >::smallSize ( ) const

inlineprivate

Definition at line 667 of file FBString.h.

                           {
    FBSTRING_ASSERT(category() == Category::isSmall);
    constexpr auto shift = kIsLittleEndian ? 0 : 2;
    auto smallShifted = static_cast<size_t>(small_[maxSmallSize]) >> shift;
    FBSTRING_ASSERT(static_cast<size_t>(maxSmallSize) >= smallShifted);
    return static_cast<size_t>(maxSmallSize) - smallShifted;
  }

template<class Char>

void folly::fbstring_core< Char >::swap ( fbstring_core< Char > &  rhs )

inline

Definition at line 425 of file FBString.h.

Referenced by folly::fbstring_core< Char >::reserveMedium(), and folly::fbstring_core< Char >::shrinkLarge().

                                {
    auto const t = ml_;
    ml_ = rhs.ml_;
    rhs.ml_ = t;
  }

template<class Char >

FOLLY_MALLOC_NOINLINE void folly::fbstring_core< Char >::unshare ( size_t  minCapacity = 0 )

inlineprivate

Definition at line 827 of file FBString.h.

References FBSTRING_ASSERT, max, and folly::fbstring_detail::podCopy().

                        {
  FBSTRING_ASSERT(category() == Category::isLarge);
  size_t effectiveCapacity = std::max(minCapacity, ml_.capacity());
  auto const newRC = RefCounted::create(&effectiveCapacity);
  // If this fails, someone placed the wrong capacity in an
  // fbstring.
  FBSTRING_ASSERT(effectiveCapacity >= ml_.capacity());
  // Also copies terminator.
  fbstring_detail::podCopy(ml_.data_, ml_.data_ + ml_.size_ + 1, newRC->data_);
  RefCounted::decrementRefs(ml_.data_);
  ml_.data_ = newRC->data_;
  ml_.setCapacity(effectiveCapacity, Category::isLarge);
  // size_ remains unchanged.
}

Member Data Documentation

union { ... }

template<class Char>

uint8_t folly::fbstring_core< Char >::bytes_[sizeof(MediumLarge)]

Definition at line 649 of file FBString.h.

template<class Char>

constexpr size_t folly::fbstring_core< Char >::capacityExtractMask

staticprivate

Initial value:

= kIsLittleEndian
      ? ~(size_t(categoryExtractMask) << kCategoryShift)
      : 0x0

Definition at line 659 of file FBString.h.

template<class Char>

constexpr uint8_t folly::fbstring_core< Char >::categoryExtractMask = kIsLittleEndian ? 0xC0 : 0x3

staticprivate

Definition at line 657 of file FBString.h.

template<class Char>

constexpr size_t folly::fbstring_core< Char >::kCategoryShift = (sizeof(size_t) - 1) * 8

staticprivate

Definition at line 658 of file FBString.h.

template<class Char>

constexpr auto folly::fbstring_core< Char >::kIsLittleEndian

staticprotected

Initial value:

=
      __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

Definition at line 337 of file FBString.h.

template<class Char>

constexpr size_t folly::fbstring_core< Char >::lastChar = sizeof(MediumLarge) - 1

staticprivate

Definition at line 654 of file FBString.h.

template<class Char>

constexpr size_t folly::fbstring_core< Char >::maxMediumSize = 254 / sizeof(Char)

staticprivate

Definition at line 656 of file FBString.h.

template<class Char>

constexpr size_t folly::fbstring_core< Char >::maxSmallSize = lastChar / sizeof(Char)

staticprivate

Definition at line 655 of file FBString.h.

template<class Char>

MediumLarge folly::fbstring_core< Char >::ml_

Definition at line 651 of file FBString.h.

Referenced by folly::fbstring_core< Char >::copyLarge(), folly::fbstring_core< Char >::copyMedium(), folly::fbstring_core< Char >::copySmall(), folly::fbstring_core< Char >::reserveMedium(), and folly::fbstring_core< char >::swap().

template<class Char>

Char folly::fbstring_core< Char >::small_[sizeof(MediumLarge)/sizeof(Char)]

Definition at line 650 of file FBString.h.

---

The documentation for this class was generated from the following file:

• proxygen/folly/folly/FBString.h