#pragma once
#include <algorithm>
#include <cstddef>
#include <cstring>
#include <stlfwd>
#include <stdexcept>
#include <string>
#include <string_view>
#include <util/system/compiler.h>
#include <util/system/yassert.h>
#include "ptr.h"
#include "utility.h"
#include "bitops.h"
#include "explicit_type.h"
#include "reserve.h"
#include "singleton.h"
#include "strbase.h"
#include "strbuf.h"
#include "string_hash.h"
#if defined(address_sanitizer_enabled) || defined(thread_sanitizer_enabled)
#include "hide_ptr.h"
#endif
template <class TCharType, class TCharTraits, class TAllocator>
void ResizeUninitialized(std::basic_string<TCharType, TCharTraits, TAllocator>& s, size_t len) {
#if defined(_YNDX_LIBCXX_ENABLE_STRING_RESIZE_UNINITIALIZED)
s.resize_uninitialized(len);
#else
s.resize(len);
#endif
}
#define Y_NOEXCEPT
#ifndef TSTRING_IS_STD_STRING
template <class T>
class TStringPtrOps {
public:
static inline void Ref(T* t) noexcept {
if (t != T::NullStr()) {
t->Ref();
}
}
static inline void UnRef(T* t) noexcept {
if (t != T::NullStr()) {
t->UnRef();
}
}
static inline long RefCount(const T* t) noexcept {
if (t == T::NullStr()) {
return -1;
}
return t->RefCount();
}
};
alignas(32) extern const char NULL_STRING_REPR[128];
struct TRefCountHolder {
TAtomicCounter C = 1;
};
template <class B>
struct TStdString: public TRefCountHolder, public B {
template <typename... Args>
inline TStdString(Args&&... args)
: B(std::forward<Args>(args)...)
{
}
inline bool IsNull() const noexcept {
return this == NullStr();
}
static TStdString* NullStr() noexcept {
#ifdef _LIBCPP_VERSION
return (TStdString*)NULL_STRING_REPR;
#else
return Singleton<TStdString>();
#endif
}
private:
friend TStringPtrOps<TStdString>;
inline void Ref() noexcept {
C.Inc();
}
inline void UnRef() noexcept {
if (C.Val() == 1 || C.Dec() == 0) {
delete this;
}
}
inline long RefCount() const noexcept {
return C.Val();
}
};
template <class TStringType>
class TBasicCharRef {
public:
using TChar = typename TStringType::TChar;
TBasicCharRef(TStringType& s, size_t pos)
: S_(s)
, Pos_(pos)
{
}
operator TChar() const {
return S_.at(Pos_);
}
TChar* operator&() {
return S_.begin() + Pos_;
}
const TChar* operator&() const {
return S_.cbegin() + Pos_;
}
TBasicCharRef& operator=(TChar c) {
Y_ASSERT(Pos_ < S_.size() || (Pos_ == S_.size() && !c));
S_.Detach()[Pos_] = c;
return *this;
}
TBasicCharRef& operator=(const TBasicCharRef& other) {
return this->operator=(static_cast<TChar>(other));
}
/*
* WARN:
* Though references are copyable types according to the standard,
* the behavior of this explicit default specification is different from the one
* implemented by the assignment operator above.
*
* An attempt to explicitly delete it will break valid invocations like
* auto c = flag ? s[i] : s[j];
*/
TBasicCharRef(const TBasicCharRef&) = default;
private:
TStringType& S_;
size_t Pos_;
};
#endif
template <typename TCharType, typename TTraits>
class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharType, TTraits> {
public:
// TODO: Move to private section
using TBase = TStringBase<TBasicString, TCharType, TTraits>;
using TStringType = std::basic_string<TCharType, TTraits>;
#ifdef TSTRING_IS_STD_STRING
using TStorage = TStringType;
using reference = typename TStorage::reference;
#else
using TStdStr = TStdString<TStringType>;
using TStorage = TIntrusivePtr<TStdStr, TStringPtrOps<TStdStr>>;
using reference = TBasicCharRef<TBasicString>;
#endif
using char_type = TCharType; // TODO: DROP
using value_type = TCharType;
using traits_type = TTraits;
using iterator = TCharType*;
using reverse_iterator = std::reverse_iterator<iterator>;
using typename TBase::const_iterator;
using typename TBase::const_reference;
using typename TBase::const_reverse_iterator;
struct TUninitialized {
explicit TUninitialized(size_t size)
: Size(size)
{
}
size_t Size;
};
static size_t max_size() noexcept {
static size_t res = TStringType().max_size();
return res;
}
protected:
#ifdef TSTRING_IS_STD_STRING
TStorage Storage_;
#else
TStorage S_;
template <typename... A>
static TStorage Construct(A&&... a) {
return {new TStdStr(std::forward<A>(a)...), typename TStorage::TNoIncrement()};
}
static TStorage Construct() noexcept {
return TStdStr::NullStr();
}
TStdStr& StdStr() noexcept {
return *S_;
}
const TStdStr& StdStr() const noexcept {
return *S_;
}
/**
* Makes a distinct copy of this string. `IsDetached()` is always true after this call.
*
* @throw std::length_error
*/
void Clone() {
Construct(StdStr()).Swap(S_);
}
size_t RefCount() const noexcept {
return S_.RefCount();
}
#endif
public:
inline const TStringType& ConstRef() const {
#ifdef TSTRING_IS_STD_STRING
return Storage_;
#else
return StdStr();
#endif
}
inline TStringType& MutRef() {
#ifdef TSTRING_IS_STD_STRING
return Storage_;
#else
Detach();
return StdStr();
#endif
}
inline const_reference operator[](size_t pos) const noexcept {
Y_ASSERT(pos <= length());
return this->data()[pos];
}
inline reference operator[](size_t pos) noexcept {
Y_ASSERT(pos <= length());
#ifdef TSTRING_IS_STD_STRING
return Storage_[pos];
#else
return reference(*this, pos);
#endif
}
using TBase::back;
inline reference back() noexcept {
Y_ASSERT(!this->empty());
#ifdef TSTRING_IS_STD_STRING
return Storage_.back();
#else
if (Y_UNLIKELY(this->empty())) {
return reference(*this, 0);
}
return reference(*this, length() - 1);
#endif
}
using TBase::front;
inline reference front() noexcept {
Y_ASSERT(!this->empty());
#ifdef TSTRING_IS_STD_STRING
return Storage_.front();
#else
return reference(*this, 0);
#endif
}
inline size_t length() const noexcept {
return ConstRef().length();
}
inline const TCharType* data() const noexcept {
return ConstRef().data();
}
inline const TCharType* c_str() const noexcept {
return ConstRef().c_str();
}
// ~~~ STL compatible method to obtain data pointer ~~~
iterator begin() {
return &*MutRef().begin();
}
iterator vend() {
return &*MutRef().end();
}
reverse_iterator rbegin() {
return reverse_iterator(vend());
}
reverse_iterator rend() {
return reverse_iterator(begin());
}
using TBase::begin; //!< const_iterator TStringBase::begin() const
using TBase::cbegin; //!< const_iterator TStringBase::cbegin() const
using TBase::cend; //!< const_iterator TStringBase::cend() const
using TBase::crbegin; //!< const_reverse_iterator TStringBase::crbegin() const
using TBase::crend; //!< const_reverse_iterator TStringBase::crend() const
using TBase::end; //!< const_iterator TStringBase::end() const
using TBase::rbegin; //!< const_reverse_iterator TStringBase::rbegin() const
using TBase::rend; //!< const_reverse_iterator TStringBase::rend() const
inline size_t capacity() const noexcept {
#ifdef TSTRING_IS_STD_STRING
return Storage_.capacity();
#else
if (S_->IsNull()) {
return 0;
}
return S_->capacity();
#endif
}
TCharType* Detach() {
#ifdef TSTRING_IS_STD_STRING
return Storage_.data();
#else
if (Y_UNLIKELY(!IsDetached())) {
Clone();
}
return (TCharType*)S_->data();
#endif
}
bool IsDetached() const {
#ifdef TSTRING_IS_STD_STRING
return true;
#else
return 1 == RefCount();
#endif
}
// ~~~ Size and capacity ~~~
TBasicString& resize(size_t n, TCharType c = ' ') { // remove or append
MutRef().resize(n, c);
return *this;
}
// ~~~ Constructor ~~~ : FAMILY0(,TBasicString)
TBasicString() noexcept
#ifndef TSTRING_IS_STD_STRING
: S_(Construct())
#endif
{
}
inline explicit TBasicString(::NDetail::TReserveTag rt)
#ifndef TSTRING_IS_STD_STRING
: S_(Construct())
#endif
{
reserve(rt.Capacity);
}
inline TBasicString(const TBasicString& s)
#ifdef TSTRING_IS_STD_STRING
: Storage_(s.Storage_)
#else
: S_(s.S_)
#endif
{
}
inline TBasicString(TBasicString&& s) noexcept
#ifdef TSTRING_IS_STD_STRING
: Storage_(std::move(s.Storage_))
#else
: S_(Construct())
#endif
{
#ifdef TSTRING_IS_STD_STRING
#else
s.swap(*this);
#endif
}
template <typename T, typename A>
explicit inline TBasicString(const std::basic_string<TCharType, T, A>& s)
: TBasicString(s.data(), s.size())
{
}
template <typename T, typename A>
inline TBasicString(std::basic_string<TCharType, T, A>&& s)
#ifdef TSTRING_IS_STD_STRING
: Storage_(std::move(s))
#else
: S_(s.empty() ? Construct() : Construct(std::move(s)))
#endif
{
}
TBasicString(const TBasicString& s, size_t pos, size_t n) Y_NOEXCEPT
#ifdef TSTRING_IS_STD_STRING
: Storage_(s.Storage_, pos, n)
#else
: S_(n ? Construct(s, pos, n) : Construct())
#endif
{
}
TBasicString(const TCharType* pc)
: TBasicString(pc, TBase::StrLen(pc))
{
}
// TODO thegeorg@: uncomment and fix clients
// TBasicString(std::nullptr_t) = delete;
TBasicString(const TCharType* pc, size_t n)
#ifdef TSTRING_IS_STD_STRING
: Storage_(pc, n)
#else
: S_(n ? Construct(pc, n) : Construct())
#endif
{
}
TBasicString(std::nullptr_t, size_t) = delete;
TBasicString(const TCharType* pc, size_t pos, size_t n)
: TBasicString(pc + pos, n)
{
}
#ifdef TSTRING_IS_STD_STRING
explicit TBasicString(TExplicitType<TCharType> c) {
Storage_.push_back(c);
}
#else
explicit TBasicString(TExplicitType<TCharType> c)
: TBasicString(&c.Value(), 1)
{
}
explicit TBasicString(const reference& c)
: TBasicString(&c, 1)
{
}
#endif
TBasicString(size_t n, TCharType c)
#ifdef TSTRING_IS_STD_STRING
: Storage_(n, c)
#else
: S_(Construct(n, c))
#endif
{
}
/**
* Constructs an uninitialized string of size `uninitialized.Size`. The proper
* way to use this ctor is via `TBasicString::Uninitialized` factory function.
*
* @throw std::length_error
*/
TBasicString(TUninitialized uninitialized) {
#if !defined(TSTRING_IS_STD_STRING)
S_ = Construct();
#endif
ReserveAndResize(uninitialized.Size);
}
TBasicString(const TCharType* b, const TCharType* e)
: TBasicString(b, e - b)
{
}
explicit TBasicString(const TBasicStringBuf<TCharType, TTraits> s)
: TBasicString(s.data(), s.size())
{
}
template <typename Traits>
explicit inline TBasicString(const std::basic_string_view<TCharType, Traits>& s)
: TBasicString(s.data(), s.size())
{
}
/**
* WARN:
* Certain invocations of this method will result in link-time error.
* You are free to implement corresponding methods in string.cpp if you need them.
*/
static TBasicString FromAscii(const ::TStringBuf& s) {
return TBasicString().AppendAscii(s);
}
static TBasicString FromUtf8(const ::TStringBuf& s) {
return TBasicString().AppendUtf8(s);
}
static TBasicString FromUtf16(const ::TWtringBuf& s) {
return TBasicString().AppendUtf16(s);
}
static TBasicString Uninitialized(size_t n) {
return TBasicString(TUninitialized(n));
}
private:
template <typename... R>
static size_t SumLength(const TBasicStringBuf<TCharType, TTraits> s1, const R&... r) noexcept {
return s1.size() + SumLength(r...);
}
template <typename... R>
static size_t SumLength(const TCharType /*s1*/, const R&... r) noexcept {
return 1 + SumLength(r...);
}
static constexpr size_t SumLength() noexcept {
return 0;
}
template <typename... R>
static void CopyAll(TCharType* p, const TBasicStringBuf<TCharType, TTraits> s, const R&... r) {
TTraits::copy(p, s.data(), s.size());
CopyAll(p + s.size(), r...);
}
template <typename... R, class TNextCharType, typename = std::enable_if_t<std::is_same<TCharType, TNextCharType>::value>>
static void CopyAll(TCharType* p, const TNextCharType s, const R&... r) {
p[0] = s;
CopyAll(p + 1, r...);
}
static void CopyAll(TCharType*) noexcept {
}
public:
Y_REINITIALIZES_OBJECT inline void clear() noexcept {
#ifdef TSTRING_IS_STD_STRING
Storage_.clear();
#else
if (IsDetached()) {
S_->clear();
return;
}
Construct().Swap(S_);
#endif
}
template <typename... R>
static inline TBasicString Join(const R&... r) {
TBasicString s{TUninitialized{SumLength(r...)}};
TBasicString::CopyAll((TCharType*)s.data(), r...);
return s;
}
// ~~~ Assignment ~~~ : FAMILY0(TBasicString&, assign);
TBasicString& assign(size_t size, TCharType ch) {
ReserveAndResize(size);
std::fill(begin(), vend(), ch);
return *this;
}
TBasicString& assign(const TBasicString& s) {
TBasicString(s).swap(*this);
return *this;
}
TBasicString& assign(const TBasicString& s, size_t pos, size_t n) {
return assign(TBasicString(s, pos, n));
}
TBasicString& assign(const TCharType* pc) {
return assign(pc, TBase::StrLen(pc));
}
TBasicString& assign(TCharType ch) {
return assign(&ch, 1);
}
TBasicString& assign(const TCharType* pc, size_t len) {
#if defined(address_sanitizer_enabled) || defined(thread_sanitizer_enabled)
pc = (const TCharType*)HidePointerOrigin((void*)pc);
#endif
if (IsDetached()) {
MutRef().assign(pc, len);
} else {
TBasicString(pc, len).swap(*this);
}
return *this;
}
TBasicString& assign(const TCharType* first, const TCharType* last) {
return assign(first, last - first);
}
TBasicString& assign(const TCharType* pc, size_t pos, size_t n) {
return assign(pc + pos, n);
}
TBasicString& assign(const TBasicStringBuf<TCharType, TTraits> s) {
return assign(s.data(), s.size());
}
TBasicString& assign(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) {
return assign(s.SubString(spos, sn));
}
inline TBasicString& AssignNoAlias(const TCharType* pc, size_t len) {
return assign(pc, len);
}
inline TBasicString& AssignNoAlias(const TCharType* b, const TCharType* e) {
return AssignNoAlias(b, e - b);
}
TBasicString& AssignNoAlias(const TBasicStringBuf<TCharType, TTraits> s) {
return AssignNoAlias(s.data(), s.size());
}
TBasicString& AssignNoAlias(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) {
return AssignNoAlias(s.SubString(spos, sn));
}
/**
* WARN:
* Certain invocations of this method will result in link-time error.
* You are free to implement corresponding methods in string.cpp if you need them.
*/
auto AssignAscii(const ::TStringBuf& s) {
clear();
return AppendAscii(s);
}
auto AssignUtf8(const ::TStringBuf& s) {
clear();
return AppendUtf8(s);
}
auto AssignUtf16(const ::TWtringBuf& s) {
clear();
return AppendUtf16(s);
}
TBasicString& operator=(const TBasicString& s) {
return assign(s);
}
TBasicString& operator=(TBasicString&& s) noexcept {
swap(s);
return *this;
}
template <typename T, typename A>
TBasicString& operator=(std::basic_string<TCharType, T, A>&& s) noexcept {
TBasicString(std::move(s)).swap(*this);
return *this;
}
TBasicString& operator=(const TBasicStringBuf<TCharType, TTraits> s) {
return assign(s);
}
TBasicString& operator=(std::initializer_list<TCharType> il) {
return assign(il.begin(), il.end());
}
TBasicString& operator=(const TCharType* s) {
return assign(s);
}
TBasicString& operator=(std::nullptr_t) = delete;
TBasicString& operator=(TExplicitType<TCharType> ch) {
return assign(ch);
}
inline void reserve(size_t len) {
MutRef().reserve(len);
}
// ~~~ Appending ~~~ : FAMILY0(TBasicString&, append);
inline TBasicString& append(size_t count, TCharType ch) {
MutRef().append(count, ch);
return *this;
}
inline TBasicString& append(const TBasicString& s) {
MutRef().append(s.ConstRef());
return *this;
}
inline TBasicString& append(const TBasicString& s, size_t pos, size_t n) {
MutRef().append(s.ConstRef(), pos, n);
return *this;
}
inline TBasicString& append(const TCharType* pc) Y_NOEXCEPT {
MutRef().append(pc);
return *this;
}
inline TBasicString& append(TCharType c) {
MutRef().push_back(c);
return *this;
}
inline TBasicString& append(const TCharType* first, const TCharType* last) {
MutRef().append(first, last);
return *this;
}
inline TBasicString& append(const TCharType* pc, size_t len) {
MutRef().append(pc, len);
return *this;
}
inline void ReserveAndResize(size_t len) {
::ResizeUninitialized(MutRef(), len);
}
TBasicString& AppendNoAlias(const TCharType* pc, size_t len) {
if (len) {
auto s = this->size();
ReserveAndResize(s + len);
memcpy(&*(begin() + s), pc, len * sizeof(*pc));
}
return *this;
}
TBasicString& AppendNoAlias(const TBasicStringBuf<TCharType, TTraits> s) {
return AppendNoAlias(s.data(), s.size());
}
TBasicString& AppendNoAlias(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) {
return AppendNoAlias(s.SubString(spos, sn));
}
TBasicString& append(const TBasicStringBuf<TCharType, TTraits> s) {
return append(s.data(), s.size());
}
TBasicString& append(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) {
return append(s.SubString(spos, sn));
}
TBasicString& append(const TCharType* pc, size_t pos, size_t n, size_t pc_len = TBase::npos) {
return append(pc + pos, Min(n, pc_len - pos));
}
/**
* WARN:
* Certain invocations of this method will result in link-time error.
* You are free to implement corresponding methods in string.cpp if you need them.
*/
TBasicString& AppendAscii(const ::TStringBuf& s);
TBasicString& AppendUtf8(const ::TStringBuf& s);
TBasicString& AppendUtf16(const ::TWtringBuf& s);
inline void push_back(TCharType c) {
// TODO
append(c);
}
template <class T>
TBasicString& operator+=(const T& s) {
return append(s);
}
template <class T>
friend TBasicString operator*(const TBasicString& s, T count) {
TBasicString result;
for (T i = 0; i < count; ++i) {
result += s;
}
return result;
}
template <class T>
TBasicString& operator*=(T count) {
TBasicString temp;
for (T i = 0; i < count; ++i) {
temp += *this;
}
swap(temp);
return *this;
}
operator const TStringType&() const noexcept {
return this->ConstRef();
}
operator TStringType&() {
return this->MutRef();
}
/*
* Following overloads of "operator+" aim to choose the cheapest implementation depending on
* summand types: lvalues, detached rvalues, shared rvalues.
*
* General idea is to use the detached-rvalue argument (left of right) to store the result
* wherever possible. If a buffer in rvalue is large enough this saves a re-allocation. If
* both arguments are rvalues we check which one is detached. If both of them are detached then
* the left argument is obviously preferrable because you won't need to shift the data.
*
* If an rvalue is shared then it's basically the same as lvalue because you cannot use its
* buffer to store the sum. However, we rely on the fact that append() and prepend() are already
* optimized for the shared case and detach the string into the buffer large enough to store
* the sum (compared to the detach+reallocation). This way, if we have only one rvalue argument
* (left or right) then we simply append/prepend into it, without checking if it's detached or
* not. This will be checked inside ReserveAndResize anyway.
*
* If both arguments cannot be used to store the sum (e.g. two lvalues) then we fall back to the
* Join function that constructs a resulting string in the new buffer with the minimum overhead:
* malloc + memcpy + memcpy.
*/
friend TBasicString operator+(TBasicString&& s1, const TBasicString& s2) Y_WARN_UNUSED_RESULT {
s1 += s2;
return std::move(s1);
}
friend TBasicString operator+(const TBasicString& s1, TBasicString&& s2) Y_WARN_UNUSED_RESULT {
s2.prepend(s1);
return std::move(s2);
}
friend TBasicString operator+(TBasicString&& s1, TBasicString&& s2) Y_WARN_UNUSED_RESULT {
#if 0 && !defined(TSTRING_IS_STD_STRING)
if (!s1.IsDetached() && s2.IsDetached()) {
s2.prepend(s1);
return std::move(s2);
}
#endif
s1 += s2;
return std::move(s1);
}
friend TBasicString operator+(TBasicString&& s1, const TBasicStringBuf<TCharType, TTraits> s2) Y_WARN_UNUSED_RESULT {
s1 += s2;
return std::move(s1);
}
friend TBasicString operator+(TBasicString&& s1, const TCharType* s2) Y_WARN_UNUSED_RESULT {
s1 += s2;
return std::move(s1);
}
friend TBasicString operator+(TBasicString&& s1, TCharType s2) Y_WARN_UNUSED_RESULT {
s1 += s2;
return std::move(s1);
}
friend TBasicString operator+(TExplicitType<TCharType> ch, const TBasicString& s) Y_WARN_UNUSED_RESULT {
return Join(TCharType(ch), s);
}
friend TBasicString operator+(TExplicitType<TCharType> ch, TBasicString&& s) Y_WARN_UNUSED_RESULT {
s.prepend(ch);
return std::move(s);
}
friend TBasicString operator+(const TBasicString& s1, const TBasicString& s2) Y_WARN_UNUSED_RESULT {
return Join(s1, s2);
}
friend TBasicString operator+(const TBasicString& s1, const TBasicStringBuf<TCharType, TTraits> s2) Y_WARN_UNUSED_RESULT {
return Join(s1, s2);
}
friend TBasicString operator+(const TBasicString& s1, const TCharType* s2) Y_WARN_UNUSED_RESULT {
return Join(s1, s2);
}
friend TBasicString operator+(const TBasicString& s1, TCharType s2) Y_WARN_UNUSED_RESULT {
return Join(s1, TBasicStringBuf<TCharType, TTraits>(&s2, 1));
}
friend TBasicString operator+(const TCharType* s1, TBasicString&& s2) Y_WARN_UNUSED_RESULT {
s2.prepend(s1);
return std::move(s2);
}
friend TBasicString operator+(const TBasicStringBuf<TCharType, TTraits> s1, TBasicString&& s2) Y_WARN_UNUSED_RESULT {
s2.prepend(s1);
return std::move(s2);
}
friend TBasicString operator+(const TBasicStringBuf<TCharType, TTraits> s1, const TBasicString& s2) Y_WARN_UNUSED_RESULT {
return Join(s1, s2);
}
friend TBasicString operator+(const TCharType* s1, const TBasicString& s2) Y_WARN_UNUSED_RESULT {
return Join(s1, s2);
}
friend TBasicString operator+(std::basic_string<TCharType, TTraits> l, TBasicString r) {
return std::move(l) + r.ConstRef();
}
friend TBasicString operator+(TBasicString l, std::basic_string<TCharType, TTraits> r) {
return l.ConstRef() + std::move(r);
}
// ~~~ Prepending ~~~ : FAMILY0(TBasicString&, prepend);
TBasicString& prepend(const TBasicString& s) {
MutRef().insert(0, s.ConstRef());
return *this;
}
TBasicString& prepend(const TBasicString& s, size_t pos, size_t n) {
MutRef().insert(0, s.ConstRef(), pos, n);
return *this;
}
TBasicString& prepend(const TCharType* pc) {
MutRef().insert(0, pc);
return *this;
}
TBasicString& prepend(size_t n, TCharType c) {
MutRef().insert(size_t(0), n, c);
return *this;
}
TBasicString& prepend(TCharType c) {
MutRef().insert(size_t(0), 1, c);
return *this;
}
TBasicString& prepend(const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) {
return insert(0, s, spos, sn);
}
// ~~~ Insertion ~~~ : FAMILY1(TBasicString&, insert, size_t pos);
TBasicString& insert(size_t pos, const TBasicString& s) {
MutRef().insert(pos, s.ConstRef());
return *this;
}
TBasicString& insert(size_t pos, const TBasicString& s, size_t pos1, size_t n1) {
MutRef().insert(pos, s.ConstRef(), pos1, n1);
return *this;
}
TBasicString& insert(size_t pos, const TCharType* pc) {
MutRef().insert(pos, pc);
return *this;
}
TBasicString& insert(size_t pos, const TCharType* pc, size_t len) {
MutRef().insert(pos, pc, len);
return *this;
}
TBasicString& insert(const_iterator pos, const_iterator b, const_iterator e) {
#ifdef TSTRING_IS_STD_STRING
Storage_.insert(Storage_.begin() + this->off(pos), b, e);
return *this;
#else
return insert(this->off(pos), b, e - b);
#endif
}
TBasicString& insert(size_t pos, size_t n, TCharType c) {
MutRef().insert(pos, n, c);
return *this;
}
TBasicString& insert(const_iterator pos, size_t len, TCharType ch) {
return this->insert(this->off(pos), len, ch);
}
TBasicString& insert(const_iterator pos, TCharType ch) {
return this->insert(pos, 1, ch);
}
TBasicString& insert(size_t pos, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) {
MutRef().insert(pos, s, spos, sn);
return *this;
}
// ~~~ Removing ~~~
TBasicString& remove(size_t pos, size_t n) Y_NOEXCEPT {
if (pos < length()) {
MutRef().erase(pos, n);
}
return *this;
}
TBasicString& remove(size_t pos = 0) Y_NOEXCEPT {
if (pos < length()) {
MutRef().erase(pos);
}
return *this;
}
TBasicString& erase(size_t pos = 0, size_t n = TBase::npos) Y_NOEXCEPT {
MutRef().erase(pos, n);
return *this;
}
TBasicString& erase(const_iterator b, const_iterator e) Y_NOEXCEPT {
return erase(this->off(b), e - b);
}
TBasicString& erase(const_iterator i) Y_NOEXCEPT {
return erase(i, i + 1);
}
TBasicString& pop_back() Y_NOEXCEPT {
Y_ASSERT(!this->empty());
MutRef().pop_back();
return *this;
}
// ~~~ replacement ~~~ : FAMILY2(TBasicString&, replace, size_t pos, size_t n);
TBasicString& replace(size_t pos, size_t n, const TBasicString& s) Y_NOEXCEPT {
MutRef().replace(pos, n, s.ConstRef());
return *this;
}
TBasicString& replace(size_t pos, size_t n, const TBasicString& s, size_t pos1, size_t n1) Y_NOEXCEPT {
MutRef().replace(pos, n, s.ConstRef(), pos1, n1);
return *this;
}
TBasicString& replace(size_t pos, size_t n, const TCharType* pc) Y_NOEXCEPT {
MutRef().replace(pos, n, pc);
return *this;
}
TBasicString& replace(size_t pos, size_t n, const TCharType* s, size_t len) Y_NOEXCEPT {
MutRef().replace(pos, n, s, len);
return *this;
}
TBasicString& replace(size_t pos, size_t n, const TCharType* s, size_t spos, size_t sn) Y_NOEXCEPT {
MutRef().replace(pos, n, s + spos, sn - spos);
return *this;
}
TBasicString& replace(size_t pos, size_t n1, size_t n2, TCharType c) Y_NOEXCEPT {
MutRef().replace(pos, n1, n2, c);
return *this;
}
TBasicString& replace(size_t pos, size_t n, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_NOEXCEPT {
MutRef().replace(pos, n, s, spos, sn);
return *this;
}
void swap(TBasicString& s) noexcept {
#ifdef TSTRING_IS_STD_STRING
std::swap(Storage_, s.Storage_);
#else
S_.Swap(s.S_);
#endif
}
/**
* @returns String suitable for debug printing (like Python's `repr()`).
* Format of the string is unspecified and may be changed over time.
*/
TBasicString Quote() const {
extern TBasicString EscapeC(const TBasicString&);
return TBasicString() + '"' + EscapeC(*this) + '"';
}
/**
* Modifies the case of the string, depending on the operation.
* @return false if no changes have been made.
*
* @warning when the value_type is char, these methods will not work with non-ASCII letters.
*/
bool to_lower(size_t pos = 0, size_t n = TBase::npos);
bool to_upper(size_t pos = 0, size_t n = TBase::npos);
bool to_title(size_t pos = 0, size_t n = TBase::npos);
public:
/**
* Modifies the substring of length `n` starting from `pos`, applying `f` to each position and symbol.
*
* @return false if no changes have been made.
*/
template <typename T>
bool Transform(T&& f, size_t pos = 0, size_t n = TBase::npos) {
size_t len = length();
if (pos > len) {
pos = len;
}
if (n > len - pos) {
n = len - pos;
}
bool changed = false;
for (size_t i = pos; i != pos + n; ++i) {
#ifdef TSTRING_IS_STD_STRING
auto c = f(i, Storage_[i]);
if (c != Storage_[i]) {
changed = true;
Storage_[i] = c;
}
#else
auto c = f(i, data()[i]);
if (c != data()[i]) {
if (!changed) {
Detach();
changed = true;
}
begin()[i] = c;
}
#endif
}
return changed;
}
};
std::ostream& operator<<(std::ostream&, const TString&);
std::istream& operator>>(std::istream&, TString&);
template <typename TCharType, typename TTraits>
TBasicString<TCharType> to_lower(const TBasicString<TCharType, TTraits>& s) {
TBasicString<TCharType> ret(s);
ret.to_lower();
return ret;
}
template <typename TCharType, typename TTraits>
TBasicString<TCharType> to_upper(const TBasicString<TCharType, TTraits>& s) {
TBasicString<TCharType> ret(s);
ret.to_upper();
return ret;
}
template <typename TCharType, typename TTraits>
TBasicString<TCharType> to_title(const TBasicString<TCharType, TTraits>& s) {
TBasicString<TCharType> ret(s);
ret.to_title();
return ret;
}
namespace std {
template <>
struct hash<TString> {
using argument_type = TString;
using result_type = size_t;
inline result_type operator()(argument_type const& s) const noexcept {
return NHashPrivate::ComputeStringHash(s.data(), s.size());
}
};
}
#undef Y_NOEXCEPT
template <class S>
inline S LegacySubstr(const S& s, size_t pos, size_t n = S::npos) {
size_t len = s.length();
pos = Min(pos, len);
n = Min(n, len - pos);
return S(s, pos, n);
}
template <typename S, typename... Args>
inline S&& LegacyReplace(S&& s, size_t pos, Args&&... args) {
if (pos <= s.length()) {
s.replace(pos, std::forward<Args>(args)...);
}
return s;
}
template <typename S, typename... Args>
inline S&& LegacyErase(S&& s, size_t pos, Args&&... args) {
if (pos <= s.length()) {
s.erase(pos, std::forward<Args>(args)...);
}
return s;
}
inline const char* LegacyStr(const char* s) noexcept {
return s ? s : "";
}
// interop
template <class TCharType, class TTraits>
auto& MutRef(TBasicString<TCharType, TTraits>& s) {
return s.MutRef();
}
template <class TCharType, class TTraits>
const auto& ConstRef(const TBasicString<TCharType, TTraits>& s) noexcept {
return s.ConstRef();
}
template <class TCharType, class TCharTraits, class TAllocator>
auto& MutRef(std::basic_string<TCharType, TCharTraits, TAllocator>& s) noexcept {
return s;
}
template <class TCharType, class TCharTraits, class TAllocator>
const auto& ConstRef(const std::basic_string<TCharType, TCharTraits, TAllocator>& s) noexcept {
return s;
}
template <class TCharType, class TTraits>
void ResizeUninitialized(TBasicString<TCharType, TTraits>& s, size_t len) {
s.ReserveAndResize(len);
}