core.stdcpp.string

enum DefaultConstruct Default;

Constructor argument for default construction

struct char_traits(CharT);

Character traits classes specify character properties and provide specific semantics for certain operations on characters and sequences of characters.

struct basic_string(T, Traits = char_traits!T, Alloc = allocator!T);

D language counterpart to C++ std::basic_string.

C++ reference:

enum size_type npos;

alias size_type = size_t;

alias difference_type = ptrdiff_t;

alias value_type = T;

alias traits_type = Traits;

alias allocator_type = Alloc;

alias pointer = value_type*;

alias const_pointer = const(value_type)*;

alias toString = as_array;

this();

MSVC allocates on default initialisation in debug, which can't be modelled by D struct

alias length = size;

alias opDollar = length;

const nothrow @safe bool empty();

const pure nothrow @nogc @safe size_t[2] opSlice(size_t dim : 0)(size_t start, size_t end);

inout pure nothrow @nogc ref @safe inout(T) opIndex(size_t index);

inout pure nothrow @nogc @safe inout(T)[] opIndex(size_t[2] slice);

inout pure nothrow @nogc @safe inout(T)[] opIndex();

const pure nothrow @safe bool opEquals(ref scope const basic_string s);

const pure nothrow @safe bool opEquals(scope const T[] s);

Two basic_strings are equal if they represent the same sequence of code units.

const pure nothrow @safe int opCmp(ref scope const basic_string rhs);

const pure nothrow @safe int opCmp(scope const T[] rhs);

Performs lexicographical comparison.

const pure nothrow @nogc @safe size_t toHash();

Hash to allow basic_strings to be used as keys for built-in associative arrays. The result will generally not be the same as C++ std::hash<std::basic_string<T>>.

void clear();

@trusted void resize(size_type n, T c = T(0));

inout nothrow ref @safe inout(T) front();

inout nothrow ref @safe inout(T) back();

const nothrow @safe const(T)* c_str();

ref basic_string opAssign()(auto ref basic_string str);

ref basic_string opAssign(const(T)[] str);

ref basic_string opAssign(T c);

ref basic_string opIndexAssign(T c, size_t index);

ref basic_string opIndexAssign(T c, size_t[2] slice);

ref basic_string opIndexAssign(const(T)[] str, size_t[2] slice);

ref basic_string opIndexAssign(T c);

ref basic_string opIndexAssign(const(T)[] str);

ref basic_string opIndexOpAssign(string op)(T c, size_t index);

ref basic_string opIndexOpAssign(string op)(T c, size_t[2] slice);

ref basic_string opIndexOpAssign(string op)(const(T)[] str, size_t[2] slice);

ref basic_string opIndexOpAssign(string op)(T c);

ref basic_string opIndexOpAssign(string op)(const(T)[] str);

ref basic_string append(T c);

ref basic_string opOpAssign(string op : "~")(const(T)[] str);

ref basic_string opOpAssign(string op : "~")(T c);

ref basic_string insert(size_type pos, ref const(basic_string) str);

ref @trusted basic_string insert(size_type pos, ref const(basic_string) str, size_type subpos, size_type sublen);

ref basic_string insert(S : size_type)(S pos, const(T)* s);

ref basic_string insert(size_type pos, const(T)[] s);

ref basic_string erase(size_type pos = 0);

ref basic_string erase(size_type pos, size_type len);

ref basic_string replace()(size_type pos, size_type len, auto ref basic_string str);

ref basic_string replace()(size_type pos, size_type len, auto ref basic_string str, size_type subpos, size_type sublen = npos);

ref basic_string replace(size_type pos, size_type len, const(value_type)[] s);

ref basic_string replace(S : size_type)(S pos, size_type len, const(value_type)* s);

@trusted void push_back(T c);

void pop_back();

this(DefaultConstruct);

this(const(T)[] str);

this(const(T)[] str, ref const(allocator_type) al);

inout ref inout(Alloc) get_allocator();

const nothrow @safe size_type max_size();

const nothrow @safe size_type size();

const nothrow @safe size_type capacity();

inout @safe inout(T)* data();

inout nothrow @trusted inout(T)[] as_array();

inout nothrow ref @trusted inout(T) at(size_type i);

ref basic_string assign(const(T)[] str);

ref basic_string assign(ref const basic_string str);

ref basic_string append(const(T)[] str);

ref basic_string append(size_type n, T c);

void reserve(size_type _Newcap = 0);

void shrink_to_fit();

ref basic_string insert(size_type pos, const(T)* s, size_type n);

ref basic_string insert(size_type pos, size_type n, T c);

ref basic_string replace(size_type pos, size_type len, const(T)* s, size_type slen);

ref basic_string replace(size_type _Off, size_type _N0, size_type _Count, T _Ch);

void swap(ref basic_string _Right);