2 * Copyright 2016 Facebook, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 // @author: Andrei Alexandrescu (aalexandre)
20 #ifndef FOLLY_BASE_FBSTRING_H_
21 #define FOLLY_BASE_FBSTRING_H_
25 #include <type_traits>
27 // This file appears in two locations: inside fbcode and in the
28 // libstdc++ source code (when embedding fbstring as std::string).
29 // To aid in this schizophrenic use, _LIBSTDCXX_FBSTRING is defined in
30 // libstdc++'s c++config.h, to gate use inside fbcode v. libstdc++.
31 #ifdef _LIBSTDCXX_FBSTRING
33 #pragma GCC system_header
35 // When used as std::string replacement always disable assertions.
38 #define FOLLY_DEFINED_NDEBUG_FOR_FBSTRING
41 // Handle the cases where the fbcode version (folly/Malloc.h) is included
42 // either before or after this inclusion.
43 #ifdef FOLLY_MALLOC_H_
44 #undef FOLLY_MALLOC_H_
45 #include "basic_fbstring_malloc.h" // nolint
47 #include "basic_fbstring_malloc.h" // nolint
48 #undef FOLLY_MALLOC_H_
51 #else // !_LIBSTDCXX_FBSTRING
53 #include <folly/Portability.h>
55 // libc++ doesn't provide this header, nor does msvc
56 #ifdef FOLLY_HAVE_BITS_CXXCONFIG_H
57 #include <bits/c++config.h>
65 #include <folly/Traits.h>
66 #include <folly/Malloc.h>
67 #include <folly/Hash.h>
68 #include <folly/ScopeGuard.h>
70 #if FOLLY_HAVE_DEPRECATED_ASSOC
71 #ifdef _GLIBCXX_SYMVER
72 #include <ext/hash_set>
73 #include <ext/hash_map>
79 // We defined these here rather than including Likely.h to avoid
80 // redefinition errors when fbstring is imported into libstdc++.
81 #if defined(__GNUC__) && __GNUC__ >= 4
82 #define FBSTRING_LIKELY(x) (__builtin_expect((x), 1))
83 #define FBSTRING_UNLIKELY(x) (__builtin_expect((x), 0))
85 #define FBSTRING_LIKELY(x) (x)
86 #define FBSTRING_UNLIKELY(x) (x)
89 #pragma GCC diagnostic push
90 // Ignore shadowing warnings within this file, so includers can use -Wshadow.
91 #pragma GCC diagnostic ignored "-Wshadow"
92 // GCC 4.9 has a false positive in setSmallSize (probably
93 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59124), disable
94 // compile-time array bound checking.
95 #pragma GCC diagnostic ignored "-Warray-bounds"
97 // FBString cannot use throw when replacing std::string, though it may still
100 #define throw FOLLY_FBSTRING_MAY_NOT_USE_THROW
102 #ifdef _LIBSTDCXX_FBSTRING
103 namespace std _GLIBCXX_VISIBILITY(default) {
104 _GLIBCXX_BEGIN_NAMESPACE_VERSION
109 #if defined(__clang__)
110 # if __has_feature(address_sanitizer)
111 # define FBSTRING_SANITIZE_ADDRESS
113 #elif defined (__GNUC__) && \
114 (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ >= 5)) && \
116 # define FBSTRING_SANITIZE_ADDRESS
119 // When compiling with ASan, always heap-allocate the string even if
120 // it would fit in-situ, so that ASan can detect access to the string
121 // buffer after it has been invalidated (destroyed, resized, etc.).
122 // Note that this flag doesn't remove support for in-situ strings, as
123 // that would break ABI-compatibility and wouldn't allow linking code
124 // compiled with this flag with code compiled without.
125 #ifdef FBSTRING_SANITIZE_ADDRESS
126 # define FBSTRING_DISABLE_SMALL_STRING_OPTIMIZATION
129 namespace fbstring_detail {
131 template <class InIt, class OutIt>
134 typename std::iterator_traits<InIt>::difference_type n,
136 for (; n != 0; --n, ++b, ++d) {
142 template <class Pod, class T>
143 inline void pod_fill(Pod* b, Pod* e, T c) {
144 assert(b && e && b <= e);
145 /*static*/ if (sizeof(T) == 1) {
148 auto const ee = b + ((e - b) & ~7u);
149 for (; b != ee; b += 8) {
160 for (; b != e; ++b) {
167 * Lightly structured memcpy, simplifies copying PODs and introduces
168 * some asserts. Unfortunately using this function may cause
169 * measurable overhead (presumably because it adjusts from a begin/end
170 * convention to a pointer/size convention, so it does some extra
171 * arithmetic even though the caller might have done the inverse
172 * adaptation outside).
175 inline void pod_copy(const Pod* b, const Pod* e, Pod* d) {
177 assert(d >= e || d + (e - b) <= b);
178 memcpy(d, b, (e - b) * sizeof(Pod));
182 * Lightly structured memmove, simplifies copying PODs and introduces
186 inline void pod_move(const Pod* b, const Pod* e, Pod* d) {
188 memmove(d, b, (e - b) * sizeof(*b));
191 } // namespace fbstring_detail
194 * Defines a special acquisition method for constructing fbstring
195 * objects. AcquireMallocatedString means that the user passes a
196 * pointer to a malloc-allocated string that the fbstring object will
199 enum class AcquireMallocatedString {};
202 * fbstring_core_model is a mock-up type that defines all required
203 * signatures of a fbstring core. The fbstring class itself uses such
204 * a core object to implement all of the numerous member functions
205 * required by the standard.
207 * If you want to define a new core, copy the definition below and
208 * implement the primitives. Then plug the core into basic_fbstring as
209 * a template argument.
211 template <class Char>
212 class fbstring_core_model {
214 fbstring_core_model();
215 fbstring_core_model(const fbstring_core_model &);
216 ~fbstring_core_model();
217 // Returns a pointer to string's buffer (currently only contiguous
218 // strings are supported). The pointer is guaranteed to be valid
219 // until the next call to a non-const member function.
220 const Char * data() const;
221 // Much like data(), except the string is prepared to support
222 // character-level changes. This call is a signal for
223 // e.g. reference-counted implementation to fork the data. The
224 // pointer is guaranteed to be valid until the next call to a
225 // non-const member function.
226 Char * mutable_data();
227 // Returns a pointer to string's buffer and guarantees that a
228 // readable '\0' lies right after the buffer. The pointer is
229 // guaranteed to be valid until the next call to a non-const member
231 const Char * c_str() const;
232 // Shrinks the string by delta characters. Asserts that delta <=
234 void shrink(size_t delta);
235 // Expands the string by delta characters (i.e. after this call
236 // size() will report the old size() plus delta) but without
237 // initializing the expanded region. The expanded region is
238 // zero-terminated. Returns a pointer to the memory to be
239 // initialized (the beginning of the expanded portion). The caller
240 // is expected to fill the expanded area appropriately.
241 // If expGrowth is true, exponential growth is guaranteed.
242 // It is not guaranteed not to reallocate even if size() + delta <
243 // capacity(), so all references to the buffer are invalidated.
244 Char* expand_noinit(size_t delta, bool expGrowth);
245 // Expands the string by one character and sets the last character
247 void push_back(Char c);
248 // Returns the string's size.
250 // Returns the string's capacity, i.e. maximum size that the string
251 // can grow to without reallocation. Note that for reference counted
252 // strings that's technically a lie - even assigning characters
253 // within the existing size would cause a reallocation.
254 size_t capacity() const;
255 // Returns true if the data underlying the string is actually shared
256 // across multiple strings (in a refcounted fashion).
257 bool isShared() const;
258 // Makes sure that at least minCapacity characters are available for
259 // the string without reallocation. For reference-counted strings,
260 // it should fork the data even if minCapacity < size().
261 void reserve(size_t minCapacity);
264 fbstring_core_model& operator=(const fbstring_core_model &);
269 * This is the core of the string. The code should work on 32- and
270 * 64-bit and both big- and little-endianan architectures with any
273 * The storage is selected as follows (assuming we store one-byte
274 * characters on a 64-bit machine): (a) "small" strings between 0 and
275 * 23 chars are stored in-situ without allocation (the rightmost byte
276 * stores the size); (b) "medium" strings from 24 through 254 chars
277 * are stored in malloc-allocated memory that is copied eagerly; (c)
278 * "large" strings of 255 chars and above are stored in a similar
279 * structure as medium arrays, except that the string is
280 * reference-counted and copied lazily. the reference count is
281 * allocated right before the character array.
283 * The discriminator between these three strategies sits in two
284 * bits of the rightmost char of the storage. If neither is set, then the
285 * string is small (and its length sits in the lower-order bits on
286 * little-endian or the high-order bits on big-endian of that
287 * rightmost character). If the MSb is set, the string is medium width.
288 * If the second MSb is set, then the string is large. On little-endian,
289 * these 2 bits are the 2 MSbs of MediumLarge::capacity_, while on
290 * big-endian, these 2 bits are the 2 LSbs. This keeps both little-endian
291 * and big-endian fbstring_core equivalent with merely different ops used
292 * to extract capacity/category.
294 template <class Char> class fbstring_core {
296 // It's MSVC, so we just have to guess ... and allow an override
298 # ifdef FOLLY_ENDIAN_BE
299 static constexpr auto kIsLittleEndian = false;
301 static constexpr auto kIsLittleEndian = true;
304 static constexpr auto kIsLittleEndian =
305 __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__;
308 fbstring_core() noexcept { reset(); }
310 fbstring_core(const fbstring_core & rhs) {
311 assert(&rhs != this);
312 // Simplest case first: small strings are bitblitted
313 if (rhs.category() == Category::isSmall) {
314 static_assert(offsetof(MediumLarge, data_) == 0,
315 "fbstring layout failure");
316 static_assert(offsetof(MediumLarge, size_) == sizeof(ml_.data_),
317 "fbstring layout failure");
318 static_assert(offsetof(MediumLarge, capacity_) == 2 * sizeof(ml_.data_),
319 "fbstring layout failure");
320 // Just write the whole thing, don't look at details. In
321 // particular we need to copy capacity anyway because we want
322 // to set the size (don't forget that the last character,
323 // which stores a short string's length, is shared with the
324 // ml_.capacity field).
326 assert(category() == Category::isSmall && this->size() == rhs.size());
327 } else if (rhs.category() == Category::isLarge) {
328 // Large strings are just refcounted
330 RefCounted::incrementRefs(ml_.data_);
331 assert(category() == Category::isLarge && size() == rhs.size());
333 // Medium strings are copied eagerly. Don't forget to allocate
334 // one extra Char for the null terminator.
335 auto const allocSize =
336 goodMallocSize((1 + rhs.ml_.size_) * sizeof(Char));
337 ml_.data_ = static_cast<Char*>(checkedMalloc(allocSize));
338 // Also copies terminator.
339 fbstring_detail::pod_copy(rhs.ml_.data_,
340 rhs.ml_.data_ + rhs.ml_.size_ + 1,
342 ml_.size_ = rhs.ml_.size_;
343 ml_.setCapacity(allocSize / sizeof(Char) - 1, Category::isMedium);
344 assert(category() == Category::isMedium);
346 assert(size() == rhs.size());
347 assert(memcmp(data(), rhs.data(), size() * sizeof(Char)) == 0);
350 fbstring_core(fbstring_core&& goner) noexcept {
353 // Clean goner's carcass
357 fbstring_core(const Char *const data, const size_t size) {
359 #ifndef _LIBSTDCXX_FBSTRING
361 assert(this->size() == size);
362 assert(memcmp(this->data(), data, size * sizeof(Char)) == 0);
367 #ifndef FBSTRING_DISABLE_SMALL_STRING_OPTIMIZATION
368 // Simplest case first: small strings are bitblitted
369 if (size <= maxSmallSize) {
370 // Layout is: Char* data_, size_t size_, size_t capacity_
371 static_assert(sizeof(*this) == sizeof(Char*) + 2 * sizeof(size_t),
372 "fbstring has unexpected size");
373 static_assert(sizeof(Char*) == sizeof(size_t),
374 "fbstring size assumption violation");
375 // sizeof(size_t) must be a power of 2
376 static_assert((sizeof(size_t) & (sizeof(size_t) - 1)) == 0,
377 "fbstring size assumption violation");
379 // If data is aligned, use fast word-wise copying. Otherwise,
380 // use conservative memcpy.
381 if (reinterpret_cast<size_t>(data) & (sizeof(size_t) - 1)) {
382 fbstring_detail::pod_copy(data, data + size, small_);
384 // Copy one word at a time.
385 // NOTE: This reads bytes which are outside the range of the
386 // string, and makes ASan unhappy, but the small case is
387 // disabled under ASan.
389 const size_t byteSize = size * sizeof(Char);
390 constexpr size_t wordWidth = sizeof(size_t);
391 switch ((byteSize + wordWidth - 1) / wordWidth) { // Number of words.
393 ml_.capacity_ = reinterpret_cast<const size_t*>(data)[2];
395 ml_.size_ = reinterpret_cast<const size_t*>(data)[1];
397 ml_.data_ = *reinterpret_cast<Char**>(const_cast<Char*>(data));
404 #endif // FBSTRING_DISABLE_SMALL_STRING_OPTIMIZATION
406 if (size <= maxMediumSize) {
407 // Medium strings are allocated normally. Don't forget to
408 // allocate one extra Char for the terminating null.
409 auto const allocSize = goodMallocSize((1 + size) * sizeof(Char));
410 ml_.data_ = static_cast<Char*>(checkedMalloc(allocSize));
411 fbstring_detail::pod_copy(data, data + size, ml_.data_);
413 ml_.setCapacity(allocSize / sizeof(Char) - 1, Category::isMedium);
415 // Large strings are allocated differently
416 size_t effectiveCapacity = size;
417 auto const newRC = RefCounted::create(data, & effectiveCapacity);
418 ml_.data_ = newRC->data_;
420 ml_.setCapacity(effectiveCapacity, Category::isLarge);
422 ml_.data_[size] = '\0';
426 ~fbstring_core() noexcept {
427 auto const c = category();
428 if (c == Category::isSmall) {
431 if (c == Category::isMedium) {
435 RefCounted::decrementRefs(ml_.data_);
438 // Snatches a previously mallocated string. The parameter "size"
439 // is the size of the string, and the parameter "allocatedSize"
440 // is the size of the mallocated block. The string must be
441 // \0-terminated, so allocatedSize >= size + 1 and data[size] == '\0'.
443 // So if you want a 2-character string, pass malloc(3) as "data",
444 // pass 2 as "size", and pass 3 as "allocatedSize".
445 fbstring_core(Char * const data,
447 const size_t allocatedSize,
448 AcquireMallocatedString) {
450 assert(allocatedSize >= size + 1);
451 assert(data[size] == '\0');
452 // Use the medium string storage
455 // Don't forget about null terminator
456 ml_.setCapacity(allocatedSize - 1, Category::isMedium);
458 // No need for the memory
464 // swap below doesn't test whether &rhs == this (and instead
465 // potentially does extra work) on the premise that the rarity of
466 // that situation actually makes the check more expensive than is
468 void swap(fbstring_core & rhs) {
474 // In C++11 data() and c_str() are 100% equivalent.
475 const Char * data() const {
479 Char * mutable_data() {
480 auto const c = category();
481 if (c == Category::isSmall) {
484 assert(c == Category::isMedium || c == Category::isLarge);
485 if (c == Category::isLarge && RefCounted::refs(ml_.data_) > 1) {
487 size_t effectiveCapacity = ml_.capacity();
488 auto const newRC = RefCounted::create(& effectiveCapacity);
489 // If this fails, someone placed the wrong capacity in an
491 assert(effectiveCapacity >= ml_.capacity());
492 // Also copies terminator.
493 fbstring_detail::pod_copy(ml_.data_, ml_.data_ + ml_.size_ + 1,
495 RefCounted::decrementRefs(ml_.data_);
496 ml_.data_ = newRC->data_;
501 const Char * c_str() const {
502 auto const c = category();
503 if (c == Category::isSmall) {
504 assert(small_[smallSize()] == '\0');
507 assert(c == Category::isMedium || c == Category::isLarge);
508 assert(ml_.data_[ml_.size_] == '\0');
512 void shrink(const size_t delta) {
513 if (category() == Category::isSmall) {
514 // Check for underflow
515 assert(delta <= smallSize());
516 setSmallSize(smallSize() - delta);
517 } else if (category() == Category::isMedium ||
518 RefCounted::refs(ml_.data_) == 1) {
519 // Medium strings and unique large strings need no special
521 assert(ml_.size_ >= delta);
523 ml_.data_[ml_.size_] = '\0';
525 assert(ml_.size_ >= delta);
526 // Shared large string, must make unique. This is because of the
527 // durn terminator must be written, which may trample the shared
530 fbstring_core(ml_.data_, ml_.size_ - delta).swap(*this);
532 // No need to write the terminator.
536 void reserve(size_t minCapacity) {
537 if (category() == Category::isLarge) {
539 if (RefCounted::refs(ml_.data_) > 1) {
540 // We must make it unique regardless; in-place reallocation is
541 // useless if the string is shared. In order to not surprise
542 // people, reserve the new block at current capacity or
543 // more. That way, a string's capacity never shrinks after a
545 minCapacity = std::max(minCapacity, ml_.capacity());
546 auto const newRC = RefCounted::create(& minCapacity);
547 // Also copies terminator.
548 fbstring_detail::pod_copy(ml_.data_, ml_.data_ + ml_.size_ + 1,
550 RefCounted::decrementRefs(ml_.data_);
551 ml_.data_ = newRC->data_;
552 ml_.setCapacity(minCapacity, Category::isLarge);
553 // size remains unchanged
555 // String is not shared, so let's try to realloc (if needed)
556 if (minCapacity > ml_.capacity()) {
557 // Asking for more memory
559 RefCounted::reallocate(ml_.data_, ml_.size_,
560 ml_.capacity(), minCapacity);
561 ml_.data_ = newRC->data_;
562 ml_.setCapacity(minCapacity, Category::isLarge);
564 assert(capacity() >= minCapacity);
566 } else if (category() == Category::isMedium) {
567 // String is not shared
568 if (minCapacity <= ml_.capacity()) {
569 return; // nothing to do, there's enough room
571 if (minCapacity <= maxMediumSize) {
572 // Keep the string at medium size. Don't forget to allocate
573 // one extra Char for the terminating null.
574 size_t capacityBytes = goodMallocSize((1 + minCapacity) * sizeof(Char));
575 // Also copies terminator.
576 ml_.data_ = static_cast<Char *>(
579 (ml_.size_ + 1) * sizeof(Char),
580 (ml_.capacity() + 1) * sizeof(Char),
582 ml_.setCapacity(capacityBytes / sizeof(Char) - 1, Category::isMedium);
584 // Conversion from medium to large string
585 fbstring_core nascent;
586 // Will recurse to another branch of this function
587 nascent.reserve(minCapacity);
588 nascent.ml_.size_ = ml_.size_;
589 // Also copies terminator.
590 fbstring_detail::pod_copy(ml_.data_, ml_.data_ + ml_.size_ + 1,
593 assert(capacity() >= minCapacity);
596 assert(category() == Category::isSmall);
597 #ifndef FBSTRING_DISABLE_SMALL_STRING_OPTIMIZATION
598 if (minCapacity <= maxSmallSize) {
600 // Nothing to do, everything stays put
602 #endif // FBSTRING_DISABLE_SMALL_STRING_OPTIMIZATION
603 if (minCapacity <= maxMediumSize) {
605 // Don't forget to allocate one extra Char for the terminating null
606 auto const allocSizeBytes =
607 goodMallocSize((1 + minCapacity) * sizeof(Char));
608 auto const pData = static_cast<Char*>(checkedMalloc(allocSizeBytes));
609 auto const size = smallSize();
610 // Also copies terminator.
611 fbstring_detail::pod_copy(small_, small_ + size + 1, pData);
614 ml_.setCapacity(allocSizeBytes / sizeof(Char) - 1, Category::isMedium);
617 auto const newRC = RefCounted::create(& minCapacity);
618 auto const size = smallSize();
619 // Also copies terminator.
620 fbstring_detail::pod_copy(small_, small_ + size + 1, newRC->data_);
621 ml_.data_ = newRC->data_;
623 ml_.setCapacity(minCapacity, Category::isLarge);
624 assert(capacity() >= minCapacity);
627 assert(capacity() >= minCapacity);
630 Char * expand_noinit(const size_t delta, bool expGrowth = false) {
631 // Strategy is simple: make room, then change size
632 assert(capacity() >= size());
634 if (category() == Category::isSmall) {
637 #ifndef FBSTRING_DISABLE_SMALL_STRING_OPTIMIZATION
638 if (FBSTRING_LIKELY(newSz <= maxSmallSize)) {
642 #endif // FBSTRING_DISABLE_SMALL_STRING_OPTIMIZATION
643 reserve(expGrowth ? std::max(newSz, 2 * maxSmallSize) : newSz);
647 if (FBSTRING_UNLIKELY(newSz > capacity())) {
648 // ensures not shared
649 reserve(expGrowth ? std::max(newSz, 1 + capacity() * 3 / 2) : newSz);
652 assert(capacity() >= newSz);
653 // Category can't be small - we took care of that above
654 assert(category() == Category::isMedium || category() == Category::isLarge);
656 ml_.data_[newSz] = '\0';
657 assert(size() == newSz);
658 return ml_.data_ + sz;
661 void push_back(Char c) {
662 *expand_noinit(1, /* expGrowth = */ true) = c;
665 size_t size() const {
666 return category() == Category::isSmall ? smallSize() : ml_.size_;
669 size_t capacity() const {
670 switch (category()) {
671 case Category::isSmall:
673 case Category::isLarge:
674 // For large-sized strings, a multi-referenced chunk has no
675 // available capacity. This is because any attempt to append
676 // data would trigger a new allocation.
677 if (RefCounted::refs(ml_.data_) > 1) return ml_.size_;
680 return ml_.capacity();
683 bool isShared() const {
684 return category() == Category::isLarge && RefCounted::refs(ml_.data_) > 1;
689 fbstring_core & operator=(const fbstring_core & rhs);
691 // Equivalent to setSmallSize(0) but a few ns faster in
694 ml_.capacity_ = kIsLittleEndian
695 ? maxSmallSize << (8 * (sizeof(size_t) - sizeof(Char)))
698 assert(category() == Category::isSmall && size() == 0);
702 std::atomic<size_t> refCount_;
705 static RefCounted * fromData(Char * p) {
706 return static_cast<RefCounted*>(
708 static_cast<unsigned char*>(static_cast<void*>(p))
709 - sizeof(refCount_)));
712 static size_t refs(Char * p) {
713 return fromData(p)->refCount_.load(std::memory_order_acquire);
716 static void incrementRefs(Char * p) {
717 fromData(p)->refCount_.fetch_add(1, std::memory_order_acq_rel);
720 static void decrementRefs(Char * p) {
721 auto const dis = fromData(p);
722 size_t oldcnt = dis->refCount_.fetch_sub(1, std::memory_order_acq_rel);
729 static RefCounted * create(size_t * size) {
730 // Don't forget to allocate one extra Char for the terminating
731 // null. In this case, however, one Char is already part of the
733 const size_t allocSize = goodMallocSize(
734 sizeof(RefCounted) + *size * sizeof(Char));
735 auto result = static_cast<RefCounted*>(checkedMalloc(allocSize));
736 result->refCount_.store(1, std::memory_order_release);
737 *size = (allocSize - sizeof(RefCounted)) / sizeof(Char);
741 static RefCounted * create(const Char * data, size_t * size) {
742 const size_t effectiveSize = *size;
743 auto result = create(size);
744 fbstring_detail::pod_copy(data, data + effectiveSize, result->data_);
748 static RefCounted * reallocate(Char *const data,
749 const size_t currentSize,
750 const size_t currentCapacity,
751 const size_t newCapacity) {
752 assert(newCapacity > 0 && newCapacity > currentSize);
753 auto const dis = fromData(data);
754 assert(dis->refCount_.load(std::memory_order_acquire) == 1);
755 // Don't forget to allocate one extra Char for the terminating
756 // null. In this case, however, one Char is already part of the
758 auto result = static_cast<RefCounted*>(
760 sizeof(RefCounted) + currentSize * sizeof(Char),
761 sizeof(RefCounted) + currentCapacity * sizeof(Char),
762 sizeof(RefCounted) + newCapacity * sizeof(Char)));
763 assert(result->refCount_.load(std::memory_order_acquire) == 1);
768 typedef std::conditional<sizeof(size_t) == 4, uint32_t, uint64_t>::type
771 enum class Category : category_type {
773 isMedium = kIsLittleEndian
774 ? sizeof(size_t) == 4 ? 0x80000000 : 0x8000000000000000
776 isLarge = kIsLittleEndian
777 ? sizeof(size_t) == 4 ? 0x40000000 : 0x4000000000000000
781 Category category() const {
782 // works for both big-endian and little-endian
783 return static_cast<Category>(ml_.capacity_ & categoryExtractMask);
791 size_t capacity() const {
792 return kIsLittleEndian
793 ? capacity_ & capacityExtractMask
797 void setCapacity(size_t cap, Category cat) {
798 capacity_ = kIsLittleEndian
799 ? cap | static_cast<category_type>(cat)
800 : (cap << 2) | static_cast<category_type>(cat);
805 Char small_[sizeof(MediumLarge) / sizeof(Char)];
810 lastChar = sizeof(MediumLarge) - 1,
811 maxSmallSize = lastChar / sizeof(Char),
812 maxMediumSize = 254 / sizeof(Char), // coincides with the small
813 // bin size in dlmalloc
814 categoryExtractMask = kIsLittleEndian
815 ? sizeof(size_t) == 4 ? 0xC0000000 : 0xC000000000000000
817 capacityExtractMask = kIsLittleEndian
818 ? ~categoryExtractMask
821 static_assert(!(sizeof(MediumLarge) % sizeof(Char)),
822 "Corrupt memory layout for fbstring.");
824 size_t smallSize() const {
825 assert(category() == Category::isSmall);
826 constexpr auto shift = kIsLittleEndian ? 0 : 2;
827 auto smallShifted = static_cast<size_t>(small_[maxSmallSize]) >> shift;
828 assert(static_cast<size_t>(maxSmallSize) >= smallShifted);
829 return static_cast<size_t>(maxSmallSize) - smallShifted;
832 void setSmallSize(size_t s) {
833 // Warning: this should work with uninitialized strings too,
834 // so don't assume anything about the previous value of
835 // small_[maxSmallSize].
836 assert(s <= maxSmallSize);
837 constexpr auto shift = kIsLittleEndian ? 0 : 2;
838 small_[maxSmallSize] = (maxSmallSize - s) << shift;
840 assert(category() == Category::isSmall && size() == s);
844 #ifndef _LIBSTDCXX_FBSTRING
846 * Dummy fbstring core that uses an actual std::string. This doesn't
847 * make any sense - it's just for testing purposes.
849 template <class Char>
850 class dummy_fbstring_core {
852 dummy_fbstring_core() {
854 dummy_fbstring_core(const dummy_fbstring_core& another)
855 : backend_(another.backend_) {
857 dummy_fbstring_core(const Char * s, size_t n)
860 void swap(dummy_fbstring_core & rhs) {
861 backend_.swap(rhs.backend_);
863 const Char * data() const {
864 return backend_.data();
866 Char * mutable_data() {
867 //assert(!backend_.empty());
868 return &*backend_.begin();
870 void shrink(size_t delta) {
871 assert(delta <= size());
872 backend_.resize(size() - delta);
874 Char * expand_noinit(size_t delta) {
875 auto const sz = size();
876 backend_.resize(size() + delta);
877 return backend_.data() + sz;
879 void push_back(Char c) {
880 backend_.push_back(c);
882 size_t size() const {
883 return backend_.size();
885 size_t capacity() const {
886 return backend_.capacity();
888 bool isShared() const {
891 void reserve(size_t minCapacity) {
892 backend_.reserve(minCapacity);
896 std::basic_string<Char> backend_;
898 #endif // !_LIBSTDCXX_FBSTRING
901 * This is the basic_string replacement. For conformity,
902 * basic_fbstring takes the same template parameters, plus the last
903 * one which is the core.
905 #ifdef _LIBSTDCXX_FBSTRING
906 template <typename E, class T, class A, class Storage>
908 template <typename E,
909 class T = std::char_traits<E>,
910 class A = std::allocator<E>,
911 class Storage = fbstring_core<E> >
913 class basic_fbstring {
917 void (*throw_exc)(const char*),
919 if (!condition) throw_exc(msg);
922 bool isSane() const {
925 empty() == (size() == 0) &&
926 empty() == (begin() == end()) &&
927 size() <= max_size() &&
928 capacity() <= max_size() &&
929 size() <= capacity() &&
930 begin()[size()] == '\0';
934 friend struct Invariant;
937 explicit Invariant(const basic_fbstring& s) : s_(s) {
944 const basic_fbstring& s_;
946 explicit Invariant(const basic_fbstring&) {}
948 Invariant& operator=(const Invariant&);
953 typedef T traits_type;
954 typedef typename traits_type::char_type value_type;
955 typedef A allocator_type;
956 typedef typename A::size_type size_type;
957 typedef typename A::difference_type difference_type;
959 typedef typename A::reference reference;
960 typedef typename A::const_reference const_reference;
961 typedef typename A::pointer pointer;
962 typedef typename A::const_pointer const_pointer;
965 typedef const E* const_iterator;
966 typedef std::reverse_iterator<iterator
967 #ifdef NO_ITERATOR_TRAITS
971 typedef std::reverse_iterator<const_iterator
972 #ifdef NO_ITERATOR_TRAITS
975 > const_reverse_iterator;
977 static const size_type npos; // = size_type(-1)
978 typedef std::true_type IsRelocatable;
981 static void procrustes(size_type& n, size_type nmax) {
982 if (n > nmax) n = nmax;
986 // C++11 21.4.2 construct/copy/destroy
988 // Note: while the following two constructors can be (and previously were)
989 // collapsed into one constructor written this way:
991 // explicit basic_fbstring(const A& a = A()) noexcept { }
993 // This can cause Clang (at least version 3.7) to fail with the error:
994 // "chosen constructor is explicit in copy-initialization ...
995 // in implicit initialization of field '(x)' with omitted initializer"
997 // if used in a struct which is default-initialized. Hence the split into
998 // these two separate constructors.
1000 basic_fbstring() noexcept : basic_fbstring(A()) {
1003 explicit basic_fbstring(const A&) noexcept {
1006 basic_fbstring(const basic_fbstring& str)
1007 : store_(str.store_) {
1011 basic_fbstring(basic_fbstring&& goner) noexcept
1012 : store_(std::move(goner.store_)) {
1015 #ifndef _LIBSTDCXX_FBSTRING
1016 // This is defined for compatibility with std::string
1017 /* implicit */ basic_fbstring(const std::string& str)
1018 : store_(str.data(), str.size()) {
1022 basic_fbstring(const basic_fbstring& str,
1025 const A& /* a */ = A()) {
1026 assign(str, pos, n);
1029 /* implicit */ basic_fbstring(const value_type* s, const A& /*a*/ = A())
1031 ? traits_type::length(s)
1032 : (std::__throw_logic_error(
1033 "basic_fbstring: null pointer initializer not valid"),
1037 basic_fbstring(const value_type* s, size_type n, const A& /*a*/ = A())
1041 basic_fbstring(size_type n, value_type c, const A& /*a*/ = A()) {
1042 auto const pData = store_.expand_noinit(n);
1043 fbstring_detail::pod_fill(pData, pData + n, c);
1046 template <class InIt>
1047 basic_fbstring(InIt begin, InIt end,
1048 typename std::enable_if<
1049 !std::is_same<typename std::remove_const<InIt>::type,
1050 value_type*>::value, const A>::type & /*a*/ = A()) {
1054 // Specialization for const char*, const char*
1055 basic_fbstring(const value_type* b, const value_type* e)
1056 : store_(b, e - b) {
1059 // Nonstandard constructor
1060 basic_fbstring(value_type *s, size_type n, size_type c,
1061 AcquireMallocatedString a)
1062 : store_(s, n, c, a) {
1065 // Construction from initialization list
1066 basic_fbstring(std::initializer_list<value_type> il) {
1067 assign(il.begin(), il.end());
1070 ~basic_fbstring() noexcept {
1073 basic_fbstring& operator=(const basic_fbstring& lhs) {
1074 Invariant checker(*this);
1076 if (FBSTRING_UNLIKELY(&lhs == this)) {
1079 auto const oldSize = size();
1080 auto const srcSize = lhs.size();
1081 if (capacity() >= srcSize && !store_.isShared()) {
1082 // great, just copy the contents
1083 if (oldSize < srcSize) {
1084 store_.expand_noinit(srcSize - oldSize);
1086 store_.shrink(oldSize - srcSize);
1088 assert(size() == srcSize);
1089 auto srcData = lhs.data();
1090 fbstring_detail::pod_copy(
1091 srcData, srcData + srcSize, store_.mutable_data());
1093 // need to reallocate, so we may as well create a brand new string
1094 basic_fbstring(lhs).swap(*this);
1100 basic_fbstring& operator=(basic_fbstring&& goner) noexcept {
1101 if (FBSTRING_UNLIKELY(&goner == this)) {
1102 // Compatibility with std::basic_string<>,
1103 // C++11 21.4.2 [string.cons] / 23 requires self-move-assignment support.
1106 // No need of this anymore
1107 this->~basic_fbstring();
1108 // Move the goner into this
1109 new(&store_) fbstring_core<E>(std::move(goner.store_));
1113 #ifndef _LIBSTDCXX_FBSTRING
1114 // Compatibility with std::string
1115 basic_fbstring & operator=(const std::string & rhs) {
1116 return assign(rhs.data(), rhs.size());
1119 // Compatibility with std::string
1120 std::string toStdString() const {
1121 return std::string(data(), size());
1124 // A lot of code in fbcode still uses this method, so keep it here for now.
1125 const basic_fbstring& toStdString() const {
1130 basic_fbstring& operator=(const value_type* s) {
1134 basic_fbstring& operator=(value_type c) {
1135 Invariant checker(*this);
1138 store_.expand_noinit(1);
1139 } else if (store_.isShared()) {
1140 basic_fbstring(1, c).swap(*this);
1143 store_.shrink(size() - 1);
1149 basic_fbstring& operator=(std::initializer_list<value_type> il) {
1150 return assign(il.begin(), il.end());
1153 // C++11 21.4.3 iterators:
1154 iterator begin() { return store_.mutable_data(); }
1156 const_iterator begin() const { return store_.data(); }
1158 const_iterator cbegin() const { return begin(); }
1161 return store_.mutable_data() + store_.size();
1164 const_iterator end() const {
1165 return store_.data() + store_.size();
1168 const_iterator cend() const { return end(); }
1170 reverse_iterator rbegin() {
1171 return reverse_iterator(end());
1174 const_reverse_iterator rbegin() const {
1175 return const_reverse_iterator(end());
1178 const_reverse_iterator crbegin() const { return rbegin(); }
1180 reverse_iterator rend() {
1181 return reverse_iterator(begin());
1184 const_reverse_iterator rend() const {
1185 return const_reverse_iterator(begin());
1188 const_reverse_iterator crend() const { return rend(); }
1191 // C++11 21.4.5, element access:
1192 const value_type& front() const { return *begin(); }
1193 const value_type& back() const {
1195 // Should be begin()[size() - 1], but that branches twice
1196 return *(end() - 1);
1198 value_type& front() { return *begin(); }
1199 value_type& back() {
1201 // Should be begin()[size() - 1], but that branches twice
1202 return *(end() - 1);
1209 // C++11 21.4.4 capacity:
1210 size_type size() const { return store_.size(); }
1212 size_type length() const { return size(); }
1214 size_type max_size() const {
1215 return std::numeric_limits<size_type>::max();
1218 void resize(const size_type n, const value_type c = value_type()) {
1219 Invariant checker(*this);
1221 auto size = this->size();
1223 store_.shrink(size - n);
1225 auto const delta = n - size;
1226 auto pData = store_.expand_noinit(delta);
1227 fbstring_detail::pod_fill(pData, pData + delta, c);
1229 assert(this->size() == n);
1232 size_type capacity() const { return store_.capacity(); }
1234 void reserve(size_type res_arg = 0) {
1235 enforce(res_arg <= max_size(), std::__throw_length_error, "");
1236 store_.reserve(res_arg);
1239 void shrink_to_fit() {
1240 // Shrink only if slack memory is sufficiently large
1241 if (capacity() < size() * 3 / 2) {
1244 basic_fbstring(cbegin(), cend()).swap(*this);
1247 void clear() { resize(0); }
1249 bool empty() const { return size() == 0; }
1251 // C++11 21.4.5 element access:
1252 const_reference operator[](size_type pos) const {
1253 return *(begin() + pos);
1256 reference operator[](size_type pos) {
1257 return *(begin() + pos);
1260 const_reference at(size_type n) const {
1261 enforce(n <= size(), std::__throw_out_of_range, "");
1265 reference at(size_type n) {
1266 enforce(n < size(), std::__throw_out_of_range, "");
1270 // C++11 21.4.6 modifiers:
1271 basic_fbstring& operator+=(const basic_fbstring& str) {
1275 basic_fbstring& operator+=(const value_type* s) {
1279 basic_fbstring& operator+=(const value_type c) {
1284 basic_fbstring& operator+=(std::initializer_list<value_type> il) {
1289 basic_fbstring& append(const basic_fbstring& str) {
1291 auto desiredSize = size() + str.size();
1293 append(str.data(), str.size());
1294 assert(size() == desiredSize);
1298 basic_fbstring& append(const basic_fbstring& str, const size_type pos,
1300 const size_type sz = str.size();
1301 enforce(pos <= sz, std::__throw_out_of_range, "");
1302 procrustes(n, sz - pos);
1303 return append(str.data() + pos, n);
1306 basic_fbstring& append(const value_type* s, size_type n) {
1307 Invariant checker(*this);
1309 if (FBSTRING_UNLIKELY(!n)) {
1310 // Unlikely but must be done
1313 auto const oldSize = size();
1314 auto const oldData = data();
1315 // Check for aliasing (rare). We could use "<=" here but in theory
1316 // those do not work for pointers unless the pointers point to
1317 // elements in the same array. For that reason we use
1318 // std::less_equal, which is guaranteed to offer a total order
1319 // over pointers. See discussion at http://goo.gl/Cy2ya for more
1321 std::less_equal<const value_type*> le;
1322 if (FBSTRING_UNLIKELY(le(oldData, s) && !le(oldData + oldSize, s))) {
1323 assert(le(s + n, oldData + oldSize));
1324 const size_type offset = s - oldData;
1325 store_.reserve(oldSize + n);
1326 // Restore the source
1327 s = data() + offset;
1330 fbstring_detail::pod_copy(
1331 s, s + n, store_.expand_noinit(n, /* expGrowth = */ true));
1332 assert(size() == oldSize + n);
1336 basic_fbstring& append(const value_type* s) {
1337 return append(s, traits_type::length(s));
1340 basic_fbstring& append(size_type n, value_type c) {
1341 resize(size() + n, c);
1345 template<class InputIterator>
1346 basic_fbstring& append(InputIterator first, InputIterator last) {
1347 insert(end(), first, last);
1351 basic_fbstring& append(std::initializer_list<value_type> il) {
1352 return append(il.begin(), il.end());
1355 void push_back(const value_type c) { // primitive
1356 store_.push_back(c);
1359 basic_fbstring& assign(const basic_fbstring& str) {
1360 if (&str == this) return *this;
1361 return assign(str.data(), str.size());
1364 basic_fbstring& assign(basic_fbstring&& str) {
1365 return *this = std::move(str);
1368 basic_fbstring& assign(const basic_fbstring& str, const size_type pos,
1370 const size_type sz = str.size();
1371 enforce(pos <= sz, std::__throw_out_of_range, "");
1372 procrustes(n, sz - pos);
1373 return assign(str.data() + pos, n);
1376 basic_fbstring& assign(const value_type* s, const size_type n) {
1377 Invariant checker(*this);
1379 // s can alias this, we need to use pod_move.
1381 fbstring_detail::pod_move(s, s + n, store_.mutable_data());
1383 assert(size() == n);
1385 const value_type *const s2 = s + size();
1386 fbstring_detail::pod_move(s, s2, store_.mutable_data());
1387 append(s2, n - size());
1388 assert(size() == n);
1390 assert(size() == n);
1394 basic_fbstring& assign(const value_type* s) {
1395 return assign(s, traits_type::length(s));
1398 basic_fbstring& assign(std::initializer_list<value_type> il) {
1399 return assign(il.begin(), il.end());
1402 template <class ItOrLength, class ItOrChar>
1403 basic_fbstring& assign(ItOrLength first_or_n, ItOrChar last_or_c) {
1404 return replace(begin(), end(), first_or_n, last_or_c);
1407 basic_fbstring& insert(size_type pos1, const basic_fbstring& str) {
1408 return insert(pos1, str.data(), str.size());
1411 basic_fbstring& insert(size_type pos1, const basic_fbstring& str,
1412 size_type pos2, size_type n) {
1413 enforce(pos2 <= str.length(), std::__throw_out_of_range, "");
1414 procrustes(n, str.length() - pos2);
1415 return insert(pos1, str.data() + pos2, n);
1418 basic_fbstring& insert(size_type pos, const value_type* s, size_type n) {
1419 enforce(pos <= length(), std::__throw_out_of_range, "");
1420 insert(begin() + pos, s, s + n);
1424 basic_fbstring& insert(size_type pos, const value_type* s) {
1425 return insert(pos, s, traits_type::length(s));
1428 basic_fbstring& insert(size_type pos, size_type n, value_type c) {
1429 enforce(pos <= length(), std::__throw_out_of_range, "");
1430 insert(begin() + pos, n, c);
1434 iterator insert(const_iterator p, const value_type c) {
1435 const size_type pos = p - begin();
1437 return begin() + pos;
1440 #ifndef _LIBSTDCXX_FBSTRING
1442 typedef std::basic_istream<value_type, traits_type> istream_type;
1445 friend inline istream_type& getline(istream_type& is,
1446 basic_fbstring& str,
1448 Invariant checker(str);
1453 size_t avail = str.capacity() - size;
1454 // fbstring has 1 byte extra capacity for the null terminator,
1455 // and getline null-terminates the read string.
1456 is.getline(str.store_.expand_noinit(avail), avail + 1, delim);
1457 size += is.gcount();
1459 if (is.bad() || is.eof() || !is.fail()) {
1460 // Done by either failure, end of file, or normal read.
1461 if (!is.bad() && !is.eof()) {
1462 --size; // gcount() also accounts for the delimiter.
1468 assert(size == str.size());
1469 assert(size == str.capacity());
1470 // Start at minimum allocation 63 + terminator = 64.
1471 str.reserve(std::max<size_t>(63, 3 * size / 2));
1472 // Clear the error so we can continue reading.
1478 friend inline istream_type& getline(istream_type& is, basic_fbstring& str) {
1479 return getline(is, str, '\n');
1484 template <int i> class Selector {};
1486 iterator insertImplDiscr(const_iterator p,
1487 size_type n, value_type c, Selector<1>) {
1488 Invariant checker(*this);
1490 auto const pos = p - begin();
1491 assert(p >= begin() && p <= end());
1492 if (capacity() - size() < n) {
1493 const size_type sz = p - begin();
1494 reserve(size() + n);
1497 const iterator oldEnd = end();
1498 if (n < size_type(oldEnd - p)) {
1499 append(oldEnd - n, oldEnd);
1500 // Also copies terminator.
1501 fbstring_detail::pod_move(&*p, &*oldEnd - n + 1, begin() + pos + n);
1502 std::fill(begin() + pos, begin() + pos + n, c);
1504 append(n - (end() - p), c);
1505 append(iterator(p), oldEnd);
1506 std::fill(iterator(p), oldEnd, c);
1508 return begin() + pos;
1511 template<class InputIter>
1512 iterator insertImplDiscr(const_iterator i,
1513 InputIter b, InputIter e, Selector<0>) {
1514 return insertImpl(i, b, e,
1515 typename std::iterator_traits<InputIter>::iterator_category());
1518 template <class FwdIterator>
1519 iterator insertImpl(const_iterator i,
1522 std::forward_iterator_tag) {
1523 Invariant checker(*this);
1525 const size_type pos = i - begin();
1526 auto n = std::distance(s1, s2);
1528 assert(pos <= size());
1530 auto oldSize = size();
1531 store_.expand_noinit(n, /* expGrowth = */ true);
1533 fbstring_detail::pod_move(b + pos, b + oldSize, b + pos + n);
1534 std::copy(s1, s2, b + pos);
1539 template <class InputIterator>
1540 iterator insertImpl(const_iterator i,
1541 InputIterator b, InputIterator e,
1542 std::input_iterator_tag) {
1543 const auto pos = i - begin();
1544 basic_fbstring temp(begin(), i);
1545 for (; b != e; ++b) {
1548 temp.append(i, cend());
1550 return begin() + pos;
1554 template <class ItOrLength, class ItOrChar>
1555 iterator insert(const_iterator p, ItOrLength first_or_n, ItOrChar last_or_c) {
1556 Selector<std::numeric_limits<ItOrLength>::is_specialized> sel;
1557 return insertImplDiscr(p, first_or_n, last_or_c, sel);
1560 iterator insert(const_iterator p, std::initializer_list<value_type> il) {
1561 return insert(p, il.begin(), il.end());
1564 basic_fbstring& erase(size_type pos = 0, size_type n = npos) {
1565 Invariant checker(*this);
1567 enforce(pos <= length(), std::__throw_out_of_range, "");
1568 procrustes(n, length() - pos);
1569 std::copy(begin() + pos + n, end(), begin() + pos);
1570 resize(length() - n);
1574 iterator erase(iterator position) {
1575 const size_type pos(position - begin());
1576 enforce(pos <= size(), std::__throw_out_of_range, "");
1578 return begin() + pos;
1581 iterator erase(iterator first, iterator last) {
1582 const size_type pos(first - begin());
1583 erase(pos, last - first);
1584 return begin() + pos;
1587 // Replaces at most n1 chars of *this, starting with pos1 with the
1589 basic_fbstring& replace(size_type pos1, size_type n1,
1590 const basic_fbstring& str) {
1591 return replace(pos1, n1, str.data(), str.size());
1594 // Replaces at most n1 chars of *this, starting with pos1,
1595 // with at most n2 chars of str starting with pos2
1596 basic_fbstring& replace(size_type pos1, size_type n1,
1597 const basic_fbstring& str,
1598 size_type pos2, size_type n2) {
1599 enforce(pos2 <= str.length(), std::__throw_out_of_range, "");
1600 return replace(pos1, n1, str.data() + pos2,
1601 std::min(n2, str.size() - pos2));
1604 // Replaces at most n1 chars of *this, starting with pos, with chars from s
1605 basic_fbstring& replace(size_type pos, size_type n1, const value_type* s) {
1606 return replace(pos, n1, s, traits_type::length(s));
1609 // Replaces at most n1 chars of *this, starting with pos, with n2
1612 // consolidated with
1614 // Replaces at most n1 chars of *this, starting with pos, with at
1615 // most n2 chars of str. str must have at least n2 chars.
1616 template <class StrOrLength, class NumOrChar>
1617 basic_fbstring& replace(size_type pos, size_type n1,
1618 StrOrLength s_or_n2, NumOrChar n_or_c) {
1619 Invariant checker(*this);
1621 enforce(pos <= size(), std::__throw_out_of_range, "");
1622 procrustes(n1, length() - pos);
1623 const iterator b = begin() + pos;
1624 return replace(b, b + n1, s_or_n2, n_or_c);
1627 basic_fbstring& replace(iterator i1, iterator i2, const basic_fbstring& str) {
1628 return replace(i1, i2, str.data(), str.length());
1631 basic_fbstring& replace(iterator i1, iterator i2, const value_type* s) {
1632 return replace(i1, i2, s, traits_type::length(s));
1636 basic_fbstring& replaceImplDiscr(iterator i1, iterator i2,
1637 const value_type* s, size_type n,
1640 assert(begin() <= i1 && i1 <= end());
1641 assert(begin() <= i2 && i2 <= end());
1642 return replace(i1, i2, s, s + n);
1645 basic_fbstring& replaceImplDiscr(iterator i1, iterator i2,
1646 size_type n2, value_type c, Selector<1>) {
1647 const size_type n1 = i2 - i1;
1649 std::fill(i1, i1 + n2, c);
1652 std::fill(i1, i2, c);
1653 insert(i2, n2 - n1, c);
1659 template <class InputIter>
1660 basic_fbstring& replaceImplDiscr(iterator i1, iterator i2,
1661 InputIter b, InputIter e,
1663 replaceImpl(i1, i2, b, e,
1664 typename std::iterator_traits<InputIter>::iterator_category());
1669 template <class FwdIterator>
1670 bool replaceAliased(iterator /* i1 */,
1672 FwdIterator /* s1 */,
1673 FwdIterator /* s2 */,
1678 template <class FwdIterator>
1679 bool replaceAliased(iterator i1, iterator i2,
1680 FwdIterator s1, FwdIterator s2, std::true_type) {
1681 static const std::less_equal<const value_type*> le =
1682 std::less_equal<const value_type*>();
1683 const bool aliased = le(&*begin(), &*s1) && le(&*s1, &*end());
1687 // Aliased replace, copy to new string
1688 basic_fbstring temp;
1689 temp.reserve(size() - (i2 - i1) + std::distance(s1, s2));
1690 temp.append(begin(), i1).append(s1, s2).append(i2, end());
1695 template <class FwdIterator>
1696 void replaceImpl(iterator i1, iterator i2,
1697 FwdIterator s1, FwdIterator s2, std::forward_iterator_tag) {
1698 Invariant checker(*this);
1700 // Handle aliased replace
1701 if (replaceAliased(i1, i2, s1, s2,
1702 std::integral_constant<bool,
1703 std::is_same<FwdIterator, iterator>::value ||
1704 std::is_same<FwdIterator, const_iterator>::value>())) {
1708 auto const n1 = i2 - i1;
1710 auto const n2 = std::distance(s1, s2);
1715 std::copy(s1, s2, i1);
1719 fbstring_detail::copy_n(s1, n1, i1);
1720 std::advance(s1, n1);
1726 template <class InputIterator>
1727 void replaceImpl(iterator i1, iterator i2,
1728 InputIterator b, InputIterator e, std::input_iterator_tag) {
1729 basic_fbstring temp(begin(), i1);
1730 temp.append(b, e).append(i2, end());
1735 template <class T1, class T2>
1736 basic_fbstring& replace(iterator i1, iterator i2,
1737 T1 first_or_n_or_s, T2 last_or_c_or_n) {
1739 num1 = std::numeric_limits<T1>::is_specialized,
1740 num2 = std::numeric_limits<T2>::is_specialized;
1741 return replaceImplDiscr(
1742 i1, i2, first_or_n_or_s, last_or_c_or_n,
1743 Selector<num1 ? (num2 ? 1 : -1) : (num2 ? 2 : 0)>());
1746 size_type copy(value_type* s, size_type n, size_type pos = 0) const {
1747 enforce(pos <= size(), std::__throw_out_of_range, "");
1748 procrustes(n, size() - pos);
1750 fbstring_detail::pod_copy(
1757 void swap(basic_fbstring& rhs) {
1758 store_.swap(rhs.store_);
1761 const value_type* c_str() const {
1762 return store_.c_str();
1765 const value_type* data() const { return c_str(); }
1767 allocator_type get_allocator() const {
1768 return allocator_type();
1771 size_type find(const basic_fbstring& str, size_type pos = 0) const {
1772 return find(str.data(), pos, str.length());
1775 size_type find(const value_type* needle, const size_type pos,
1776 const size_type nsize) const {
1777 if (!nsize) return pos;
1778 auto const size = this->size();
1779 // nsize + pos can overflow (eg pos == npos), guard against that by checking
1780 // that nsize + pos does not wrap around.
1781 if (nsize + pos > size || nsize + pos < pos) return npos;
1782 // Don't use std::search, use a Boyer-Moore-like trick by comparing
1783 // the last characters first
1784 auto const haystack = data();
1785 auto const nsize_1 = nsize - 1;
1786 auto const lastNeedle = needle[nsize_1];
1788 // Boyer-Moore skip value for the last char in the needle. Zero is
1789 // not a valid value; skip will be computed the first time it's
1793 const E * i = haystack + pos;
1794 auto iEnd = haystack + size - nsize_1;
1797 // Boyer-Moore: match the last element in the needle
1798 while (i[nsize_1] != lastNeedle) {
1804 // Here we know that the last char matches
1805 // Continue in pedestrian mode
1806 for (size_t j = 0; ; ) {
1808 if (i[j] != needle[j]) {
1809 // Not found, we can skip
1810 // Compute the skip value lazily
1813 while (skip <= nsize_1 && needle[nsize_1 - skip] != lastNeedle) {
1820 // Check if done searching
1823 return i - haystack;
1830 size_type find(const value_type* s, size_type pos = 0) const {
1831 return find(s, pos, traits_type::length(s));
1834 size_type find (value_type c, size_type pos = 0) const {
1835 return find(&c, pos, 1);
1838 size_type rfind(const basic_fbstring& str, size_type pos = npos) const {
1839 return rfind(str.data(), pos, str.length());
1842 size_type rfind(const value_type* s, size_type pos, size_type n) const {
1843 if (n > length()) return npos;
1844 pos = std::min(pos, length() - n);
1845 if (n == 0) return pos;
1847 const_iterator i(begin() + pos);
1849 if (traits_type::eq(*i, *s)
1850 && traits_type::compare(&*i, s, n) == 0) {
1853 if (i == begin()) break;
1858 size_type rfind(const value_type* s, size_type pos = npos) const {
1859 return rfind(s, pos, traits_type::length(s));
1862 size_type rfind(value_type c, size_type pos = npos) const {
1863 return rfind(&c, pos, 1);
1866 size_type find_first_of(const basic_fbstring& str, size_type pos = 0) const {
1867 return find_first_of(str.data(), pos, str.length());
1870 size_type find_first_of(const value_type* s,
1871 size_type pos, size_type n) const {
1872 if (pos > length() || n == 0) return npos;
1873 const_iterator i(begin() + pos),
1875 for (; i != finish; ++i) {
1876 if (traits_type::find(s, n, *i) != 0) {
1883 size_type find_first_of(const value_type* s, size_type pos = 0) const {
1884 return find_first_of(s, pos, traits_type::length(s));
1887 size_type find_first_of(value_type c, size_type pos = 0) const {
1888 return find_first_of(&c, pos, 1);
1891 size_type find_last_of (const basic_fbstring& str,
1892 size_type pos = npos) const {
1893 return find_last_of(str.data(), pos, str.length());
1896 size_type find_last_of (const value_type* s, size_type pos,
1897 size_type n) const {
1898 if (!empty() && n > 0) {
1899 pos = std::min(pos, length() - 1);
1900 const_iterator i(begin() + pos);
1902 if (traits_type::find(s, n, *i) != 0) {
1905 if (i == begin()) break;
1911 size_type find_last_of (const value_type* s,
1912 size_type pos = npos) const {
1913 return find_last_of(s, pos, traits_type::length(s));
1916 size_type find_last_of (value_type c, size_type pos = npos) const {
1917 return find_last_of(&c, pos, 1);
1920 size_type find_first_not_of(const basic_fbstring& str,
1921 size_type pos = 0) const {
1922 return find_first_not_of(str.data(), pos, str.size());
1925 size_type find_first_not_of(const value_type* s, size_type pos,
1926 size_type n) const {
1927 if (pos < length()) {
1931 for (; i != finish; ++i) {
1932 if (traits_type::find(s, n, *i) == 0) {
1940 size_type find_first_not_of(const value_type* s,
1941 size_type pos = 0) const {
1942 return find_first_not_of(s, pos, traits_type::length(s));
1945 size_type find_first_not_of(value_type c, size_type pos = 0) const {
1946 return find_first_not_of(&c, pos, 1);
1949 size_type find_last_not_of(const basic_fbstring& str,
1950 size_type pos = npos) const {
1951 return find_last_not_of(str.data(), pos, str.length());
1954 size_type find_last_not_of(const value_type* s, size_type pos,
1955 size_type n) const {
1956 if (!this->empty()) {
1957 pos = std::min(pos, size() - 1);
1958 const_iterator i(begin() + pos);
1960 if (traits_type::find(s, n, *i) == 0) {
1963 if (i == begin()) break;
1969 size_type find_last_not_of(const value_type* s,
1970 size_type pos = npos) const {
1971 return find_last_not_of(s, pos, traits_type::length(s));
1974 size_type find_last_not_of (value_type c, size_type pos = npos) const {
1975 return find_last_not_of(&c, pos, 1);
1978 basic_fbstring substr(size_type pos = 0, size_type n = npos) const& {
1979 enforce(pos <= size(), std::__throw_out_of_range, "");
1980 return basic_fbstring(data() + pos, std::min(n, size() - pos));
1983 basic_fbstring substr(size_type pos = 0, size_type n = npos) && {
1984 enforce(pos <= size(), std::__throw_out_of_range, "");
1986 if (n < size()) resize(n);
1987 return std::move(*this);
1990 int compare(const basic_fbstring& str) const {
1991 // FIX due to Goncalo N M de Carvalho July 18, 2005
1992 return compare(0, size(), str);
1995 int compare(size_type pos1, size_type n1,
1996 const basic_fbstring& str) const {
1997 return compare(pos1, n1, str.data(), str.size());
2000 int compare(size_type pos1, size_type n1,
2001 const value_type* s) const {
2002 return compare(pos1, n1, s, traits_type::length(s));
2005 int compare(size_type pos1, size_type n1,
2006 const value_type* s, size_type n2) const {
2007 enforce(pos1 <= size(), std::__throw_out_of_range, "");
2008 procrustes(n1, size() - pos1);
2009 // The line below fixed by Jean-Francois Bastien, 04-23-2007. Thanks!
2010 const int r = traits_type::compare(pos1 + data(), s, std::min(n1, n2));
2011 return r != 0 ? r : n1 > n2 ? 1 : n1 < n2 ? -1 : 0;
2014 int compare(size_type pos1, size_type n1,
2015 const basic_fbstring& str,
2016 size_type pos2, size_type n2) const {
2017 enforce(pos2 <= str.size(), std::__throw_out_of_range, "");
2018 return compare(pos1, n1, str.data() + pos2,
2019 std::min(n2, str.size() - pos2));
2022 // Code from Jean-Francois Bastien (03/26/2007)
2023 int compare(const value_type* s) const {
2024 // Could forward to compare(0, size(), s, traits_type::length(s))
2025 // but that does two extra checks
2026 const size_type n1(size()), n2(traits_type::length(s));
2027 const int r = traits_type::compare(data(), s, std::min(n1, n2));
2028 return r != 0 ? r : n1 > n2 ? 1 : n1 < n2 ? -1 : 0;
2036 // non-member functions
2038 template <typename E, class T, class A, class S>
2040 basic_fbstring<E, T, A, S> operator+(const basic_fbstring<E, T, A, S>& lhs,
2041 const basic_fbstring<E, T, A, S>& rhs) {
2043 basic_fbstring<E, T, A, S> result;
2044 result.reserve(lhs.size() + rhs.size());
2045 result.append(lhs).append(rhs);
2046 return std::move(result);
2050 template <typename E, class T, class A, class S>
2052 basic_fbstring<E, T, A, S> operator+(basic_fbstring<E, T, A, S>&& lhs,
2053 const basic_fbstring<E, T, A, S>& rhs) {
2054 return std::move(lhs.append(rhs));
2058 template <typename E, class T, class A, class S>
2060 basic_fbstring<E, T, A, S> operator+(const basic_fbstring<E, T, A, S>& lhs,
2061 basic_fbstring<E, T, A, S>&& rhs) {
2062 if (rhs.capacity() >= lhs.size() + rhs.size()) {
2063 // Good, at least we don't need to reallocate
2064 return std::move(rhs.insert(0, lhs));
2066 // Meh, no go. Forward to operator+(const&, const&).
2067 auto const& rhsC = rhs;
2072 template <typename E, class T, class A, class S>
2074 basic_fbstring<E, T, A, S> operator+(basic_fbstring<E, T, A, S>&& lhs,
2075 basic_fbstring<E, T, A, S>&& rhs) {
2076 return std::move(lhs.append(rhs));
2080 template <typename E, class T, class A, class S>
2082 basic_fbstring<E, T, A, S> operator+(
2084 const basic_fbstring<E, T, A, S>& rhs) {
2086 basic_fbstring<E, T, A, S> result;
2087 const auto len = basic_fbstring<E, T, A, S>::traits_type::length(lhs);
2088 result.reserve(len + rhs.size());
2089 result.append(lhs, len).append(rhs);
2094 template <typename E, class T, class A, class S>
2096 basic_fbstring<E, T, A, S> operator+(
2098 basic_fbstring<E, T, A, S>&& rhs) {
2100 const auto len = basic_fbstring<E, T, A, S>::traits_type::length(lhs);
2101 if (rhs.capacity() >= len + rhs.size()) {
2102 // Good, at least we don't need to reallocate
2103 rhs.insert(rhs.begin(), lhs, lhs + len);
2106 // Meh, no go. Do it by hand since we have len already.
2107 basic_fbstring<E, T, A, S> result;
2108 result.reserve(len + rhs.size());
2109 result.append(lhs, len).append(rhs);
2114 template <typename E, class T, class A, class S>
2116 basic_fbstring<E, T, A, S> operator+(
2118 const basic_fbstring<E, T, A, S>& rhs) {
2120 basic_fbstring<E, T, A, S> result;
2121 result.reserve(1 + rhs.size());
2122 result.push_back(lhs);
2128 template <typename E, class T, class A, class S>
2130 basic_fbstring<E, T, A, S> operator+(
2132 basic_fbstring<E, T, A, S>&& rhs) {
2134 if (rhs.capacity() > rhs.size()) {
2135 // Good, at least we don't need to reallocate
2136 rhs.insert(rhs.begin(), lhs);
2139 // Meh, no go. Forward to operator+(E, const&).
2140 auto const& rhsC = rhs;
2145 template <typename E, class T, class A, class S>
2147 basic_fbstring<E, T, A, S> operator+(
2148 const basic_fbstring<E, T, A, S>& lhs,
2151 typedef typename basic_fbstring<E, T, A, S>::size_type size_type;
2152 typedef typename basic_fbstring<E, T, A, S>::traits_type traits_type;
2154 basic_fbstring<E, T, A, S> result;
2155 const size_type len = traits_type::length(rhs);
2156 result.reserve(lhs.size() + len);
2157 result.append(lhs).append(rhs, len);
2161 // C++11 21.4.8.1/10
2162 template <typename E, class T, class A, class S>
2164 basic_fbstring<E, T, A, S> operator+(
2165 basic_fbstring<E, T, A, S>&& lhs,
2168 return std::move(lhs += rhs);
2171 // C++11 21.4.8.1/11
2172 template <typename E, class T, class A, class S>
2174 basic_fbstring<E, T, A, S> operator+(
2175 const basic_fbstring<E, T, A, S>& lhs,
2178 basic_fbstring<E, T, A, S> result;
2179 result.reserve(lhs.size() + 1);
2181 result.push_back(rhs);
2185 // C++11 21.4.8.1/12
2186 template <typename E, class T, class A, class S>
2188 basic_fbstring<E, T, A, S> operator+(
2189 basic_fbstring<E, T, A, S>&& lhs,
2192 return std::move(lhs += rhs);
2195 template <typename E, class T, class A, class S>
2197 bool operator==(const basic_fbstring<E, T, A, S>& lhs,
2198 const basic_fbstring<E, T, A, S>& rhs) {
2199 return lhs.size() == rhs.size() && lhs.compare(rhs) == 0; }
2201 template <typename E, class T, class A, class S>
2203 bool operator==(const typename basic_fbstring<E, T, A, S>::value_type* lhs,
2204 const basic_fbstring<E, T, A, S>& rhs) {
2205 return rhs == lhs; }
2207 template <typename E, class T, class A, class S>
2209 bool operator==(const basic_fbstring<E, T, A, S>& lhs,
2210 const typename basic_fbstring<E, T, A, S>::value_type* rhs) {
2211 return lhs.compare(rhs) == 0; }
2213 template <typename E, class T, class A, class S>
2215 bool operator!=(const basic_fbstring<E, T, A, S>& lhs,
2216 const basic_fbstring<E, T, A, S>& rhs) {
2217 return !(lhs == rhs); }
2219 template <typename E, class T, class A, class S>
2221 bool operator!=(const typename basic_fbstring<E, T, A, S>::value_type* lhs,
2222 const basic_fbstring<E, T, A, S>& rhs) {
2223 return !(lhs == rhs); }
2225 template <typename E, class T, class A, class S>
2227 bool operator!=(const basic_fbstring<E, T, A, S>& lhs,
2228 const typename basic_fbstring<E, T, A, S>::value_type* rhs) {
2229 return !(lhs == rhs); }
2231 template <typename E, class T, class A, class S>
2233 bool operator<(const basic_fbstring<E, T, A, S>& lhs,
2234 const basic_fbstring<E, T, A, S>& rhs) {
2235 return lhs.compare(rhs) < 0; }
2237 template <typename E, class T, class A, class S>
2239 bool operator<(const basic_fbstring<E, T, A, S>& lhs,
2240 const typename basic_fbstring<E, T, A, S>::value_type* rhs) {
2241 return lhs.compare(rhs) < 0; }
2243 template <typename E, class T, class A, class S>
2245 bool operator<(const typename basic_fbstring<E, T, A, S>::value_type* lhs,
2246 const basic_fbstring<E, T, A, S>& rhs) {
2247 return rhs.compare(lhs) > 0; }
2249 template <typename E, class T, class A, class S>
2251 bool operator>(const basic_fbstring<E, T, A, S>& lhs,
2252 const basic_fbstring<E, T, A, S>& rhs) {
2255 template <typename E, class T, class A, class S>
2257 bool operator>(const basic_fbstring<E, T, A, S>& lhs,
2258 const typename basic_fbstring<E, T, A, S>::value_type* rhs) {
2261 template <typename E, class T, class A, class S>
2263 bool operator>(const typename basic_fbstring<E, T, A, S>::value_type* lhs,
2264 const basic_fbstring<E, T, A, S>& rhs) {
2267 template <typename E, class T, class A, class S>
2269 bool operator<=(const basic_fbstring<E, T, A, S>& lhs,
2270 const basic_fbstring<E, T, A, S>& rhs) {
2271 return !(rhs < lhs); }
2273 template <typename E, class T, class A, class S>
2275 bool operator<=(const basic_fbstring<E, T, A, S>& lhs,
2276 const typename basic_fbstring<E, T, A, S>::value_type* rhs) {
2277 return !(rhs < lhs); }
2279 template <typename E, class T, class A, class S>
2281 bool operator<=(const typename basic_fbstring<E, T, A, S>::value_type* lhs,
2282 const basic_fbstring<E, T, A, S>& rhs) {
2283 return !(rhs < lhs); }
2285 template <typename E, class T, class A, class S>
2287 bool operator>=(const basic_fbstring<E, T, A, S>& lhs,
2288 const basic_fbstring<E, T, A, S>& rhs) {
2289 return !(lhs < rhs); }
2291 template <typename E, class T, class A, class S>
2293 bool operator>=(const basic_fbstring<E, T, A, S>& lhs,
2294 const typename basic_fbstring<E, T, A, S>::value_type* rhs) {
2295 return !(lhs < rhs); }
2297 template <typename E, class T, class A, class S>
2299 bool operator>=(const typename basic_fbstring<E, T, A, S>::value_type* lhs,
2300 const basic_fbstring<E, T, A, S>& rhs) {
2301 return !(lhs < rhs);
2305 template <typename E, class T, class A, class S>
2306 void swap(basic_fbstring<E, T, A, S>& lhs, basic_fbstring<E, T, A, S>& rhs) {
2310 // TODO: make this faster.
2311 template <typename E, class T, class A, class S>
2314 typename basic_fbstring<E, T, A, S>::value_type,
2315 typename basic_fbstring<E, T, A, S>::traits_type>&
2317 std::basic_istream<typename basic_fbstring<E, T, A, S>::value_type,
2318 typename basic_fbstring<E, T, A, S>::traits_type>& is,
2319 basic_fbstring<E, T, A, S>& str) {
2320 typename std::basic_istream<E, T>::sentry sentry(is);
2321 typedef std::basic_istream<typename basic_fbstring<E, T, A, S>::value_type,
2322 typename basic_fbstring<E, T, A, S>::traits_type>
2324 typedef typename __istream_type::ios_base __ios_base;
2325 size_t extracted = 0;
2326 auto err = __ios_base::goodbit;
2328 auto n = is.width();
2333 for (auto got = is.rdbuf()->sgetc(); extracted != size_t(n); ++extracted) {
2334 if (got == T::eof()) {
2335 err |= __ios_base::eofbit;
2339 if (isspace(got)) break;
2341 got = is.rdbuf()->snextc();
2345 err |= __ios_base::failbit;
2353 template <typename E, class T, class A, class S>
2355 std::basic_ostream<typename basic_fbstring<E, T, A, S>::value_type,
2356 typename basic_fbstring<E, T, A, S>::traits_type>&
2358 std::basic_ostream<typename basic_fbstring<E, T, A, S>::value_type,
2359 typename basic_fbstring<E, T, A, S>::traits_type>& os,
2360 const basic_fbstring<E, T, A, S>& str) {
2362 typename std::basic_ostream<
2363 typename basic_fbstring<E, T, A, S>::value_type,
2364 typename basic_fbstring<E, T, A, S>::traits_type>::sentry __s(os);
2366 typedef std::ostreambuf_iterator<
2367 typename basic_fbstring<E, T, A, S>::value_type,
2368 typename basic_fbstring<E, T, A, S>::traits_type> _Ip;
2369 size_t __len = str.size();
2371 (os.flags() & std::ios_base::adjustfield) == std::ios_base::left;
2372 if (__pad_and_output(_Ip(os),
2374 __left ? str.data() + __len : str.data(),
2377 os.fill()).failed()) {
2378 os.setstate(std::ios_base::badbit | std::ios_base::failbit);
2381 #elif defined(_MSC_VER)
2382 // MSVC doesn't define __ostream_insert
2383 os.write(str.data(), str.size());
2385 std::__ostream_insert(os, str.data(), str.size());
2390 template <typename E1, class T, class A, class S>
2391 const typename basic_fbstring<E1, T, A, S>::size_type
2392 basic_fbstring<E1, T, A, S>::npos =
2393 static_cast<typename basic_fbstring<E1, T, A, S>::size_type>(-1);
2395 #ifndef _LIBSTDCXX_FBSTRING
2396 // basic_string compatibility routines
2398 template <typename E, class T, class A, class S>
2400 bool operator==(const basic_fbstring<E, T, A, S>& lhs,
2401 const std::string& rhs) {
2402 return lhs.compare(0, lhs.size(), rhs.data(), rhs.size()) == 0;
2405 template <typename E, class T, class A, class S>
2407 bool operator==(const std::string& lhs,
2408 const basic_fbstring<E, T, A, S>& rhs) {
2412 template <typename E, class T, class A, class S>
2414 bool operator!=(const basic_fbstring<E, T, A, S>& lhs,
2415 const std::string& rhs) {
2416 return !(lhs == rhs);
2419 template <typename E, class T, class A, class S>
2421 bool operator!=(const std::string& lhs,
2422 const basic_fbstring<E, T, A, S>& rhs) {
2423 return !(lhs == rhs);
2426 #if !defined(_LIBSTDCXX_FBSTRING)
2427 typedef basic_fbstring<char> fbstring;
2430 // fbstring is relocatable
2431 template <class T, class R, class A, class S>
2432 FOLLY_ASSUME_RELOCATABLE(basic_fbstring<T, R, A, S>);
2435 _GLIBCXX_END_NAMESPACE_VERSION
2438 } // namespace folly
2440 #ifndef _LIBSTDCXX_FBSTRING
2442 // Hash functions to make fbstring usable with e.g. hash_map
2444 // Handle interaction with different C++ standard libraries, which
2445 // expect these types to be in different namespaces.
2447 #define FOLLY_FBSTRING_HASH1(T) \
2449 struct hash< ::folly::basic_fbstring<T> > { \
2450 size_t operator()(const ::folly::fbstring& s) const { \
2451 return ::folly::hash::fnv32_buf(s.data(), s.size()); \
2455 // The C++11 standard says that these four are defined
2456 #define FOLLY_FBSTRING_HASH \
2457 FOLLY_FBSTRING_HASH1(char) \
2458 FOLLY_FBSTRING_HASH1(char16_t) \
2459 FOLLY_FBSTRING_HASH1(char32_t) \
2460 FOLLY_FBSTRING_HASH1(wchar_t)
2468 #if FOLLY_HAVE_DEPRECATED_ASSOC
2469 #if defined(_GLIBCXX_SYMVER) && !defined(__BIONIC__)
2470 namespace __gnu_cxx {
2474 } // namespace __gnu_cxx
2475 #endif // _GLIBCXX_SYMVER && !__BIONIC__
2476 #endif // FOLLY_HAVE_DEPRECATED_ASSOC
2478 #undef FOLLY_FBSTRING_HASH
2479 #undef FOLLY_FBSTRING_HASH1
2481 #endif // _LIBSTDCXX_FBSTRING
2483 #pragma GCC diagnostic pop
2485 #undef FBSTRING_DISABLE_SMALL_STRING_OPTIMIZATION
2486 #undef FBSTRING_SANITIZE_ADDRESS
2488 #undef FBSTRING_LIKELY
2489 #undef FBSTRING_UNLIKELY
2491 #ifdef FOLLY_DEFINED_NDEBUG_FOR_FBSTRING
2493 #undef FOLLY_DEFINED_NDEBUG_FOR_FBSTRING
2494 #endif // FOLLY_DEFINED_NDEBUG_FOR_FBSTRING
2496 #endif // FOLLY_BASE_FBSTRING_H_