SkString Class Reference

#include <SkString.h>

Inheritance diagram for SkString:

Public Types
using	sk_is_trivially_relocatable = std::true_type

Public Member Functions
	SkString ()
	SkString (size_t len)
	SkString (const char text[])
	SkString (const char text[], size_t len)
	SkString (const SkString &)
	SkString (SkString &&)
	SkString (const std::string &)
	SkString (std::string_view)
	~SkString ()
bool	isEmpty () const
size_t	size () const
const char *	data () const
const char *	c_str () const
char	operator[] (size_t n) const
bool	equals (const SkString &) const
bool	equals (const char text[]) const
bool	equals (const char text[], size_t len) const
bool	startsWith (const char prefixStr[]) const
bool	startsWith (const char prefixChar) const
bool	endsWith (const char suffixStr[]) const
bool	endsWith (const char suffixChar) const
bool	contains (const char substring[]) const
bool	contains (const char subchar) const
int	find (const char substring[]) const
int	findLastOf (const char subchar) const
SkString &	operator= (const SkString &)
SkString &	operator= (SkString &&)
SkString &	operator= (const char text[])
char *	data ()
char &	operator[] (size_t n)
void	reset ()
void	resize (size_t len)
void	set (const SkString &src)
void	set (const char text[])
void	set (const char text[], size_t len)
void	set (std::string_view str)
void	insert (size_t offset, const char text[])
void	insert (size_t offset, const char text[], size_t len)
void	insert (size_t offset, const SkString &str)
void	insert (size_t offset, std::string_view str)
void	insertUnichar (size_t offset, SkUnichar)
void	insertS32 (size_t offset, int32_t value)
void	insertS64 (size_t offset, int64_t value, int minDigits=0)
void	insertU32 (size_t offset, uint32_t value)
void	insertU64 (size_t offset, uint64_t value, int minDigits=0)
void	insertHex (size_t offset, uint32_t value, int minDigits=0)
void	insertScalar (size_t offset, SkScalar)
void	append (const char text[])
void	append (const char text[], size_t len)
void	append (const SkString &str)
void	append (std::string_view str)
void	appendUnichar (SkUnichar uni)
void	appendS32 (int32_t value)
void	appendS64 (int64_t value, int minDigits=0)
void	appendU32 (uint32_t value)
void	appendU64 (uint64_t value, int minDigits=0)
void	appendHex (uint32_t value, int minDigits=0)
void	appendScalar (SkScalar value)
void	prepend (const char text[])
void	prepend (const char text[], size_t len)
void	prepend (const SkString &str)
void	prepend (std::string_view str)
void	prependUnichar (SkUnichar uni)
void	prependS32 (int32_t value)
void	prependS64 (int32_t value, int minDigits=0)
void	prependHex (uint32_t value, int minDigits=0)
void	prependScalar (SkScalar value)
void	printf (const char format[],...) SK_PRINTF_LIKE(2
void void	printVAList (const char format[], va_list) SK_PRINTF_LIKE(2
void void void	appendf (const char format[],...) SK_PRINTF_LIKE(2
void void void void	appendVAList (const char format[], va_list) SK_PRINTF_LIKE(2
void void void void void	prependf (const char format[],...) SK_PRINTF_LIKE(2
void void void void void void	prependVAList (const char format[], va_list) SK_PRINTF_LIKE(2
void void void void void void void	remove (size_t offset, size_t length)
SkString &	operator+= (const SkString &s)
SkString &	operator+= (const char text[])
SkString &	operator+= (const char c)
void	swap (SkString &other)

Friends
bool	operator== (const SkString &a, const SkString &b)
bool	operator!= (const SkString &a, const SkString &b)

Detailed Description

Light weight class for managing strings. Uses reference counting to make string assignments and copies very fast with no extra RAM cost. Assumes UTF8 encoding.

Definition at line 118 of file SkString.h.

Member Typedef Documentation

sk_is_trivially_relocatable

using SkString::sk_is_trivially_relocatable = std::true_type

Definition at line 244 of file SkString.h.

Constructor & Destructor Documentation

SkString() [1/8]

SkString::SkString

(

)

Definition at line 289 of file SkString.cpp.

                   : fRec(const_cast<Rec*>(&gEmptyRec)) {
}

SkString() [2/8]

SkString::SkString ( size_t  len )

explicit

Definition at line 292 of file SkString.cpp.

                             {
    fRec = Rec::Make(nullptr, len);
}

SkString() [3/8]

SkString::SkString ( const char  text[] )

explicit

Definition at line 296 of file SkString.cpp.

                                    {
    size_t  len = text ? strlen(text) : 0;
 
    fRec = Rec::Make(text, len);
}

SkString() [4/8]

SkString::SkString	(	const char	text[],
		size_t	len
	)

Definition at line 302 of file SkString.cpp.

                                                {
    fRec = Rec::Make(text, len);
}

SkString() [5/8]

SkString::SkString

(

const SkString &

src

)

Definition at line 306 of file SkString.cpp.

: fRec(src.validate().fRec) {}

SkString() [6/8]

SkString::SkString

(

SkString &&

src

)

Definition at line 308 of file SkString.cpp.

                                 : fRec(std::move(src.validate().fRec)) {
    src.fRec.reset(const_cast<Rec*>(&gEmptyRec));
}

SkString() [7/8]

SkString::SkString ( const std::string &  src )

explicit

Definition at line 312 of file SkString.cpp.

                                       {
    fRec = Rec::Make(src.c_str(), src.size());
}

SkString() [8/8]

SkString::SkString ( std::string_view  src )

explicit

Definition at line 316 of file SkString.cpp.

                                     {
    fRec = Rec::Make(src.data(), src.length());
}

~SkString()

SkString::~SkString

(

)

Definition at line 320 of file SkString.cpp.

                    {
    this->validate();
}

Member Function Documentation

append() [1/4]

void SkString::append ( const char  text[] )

inline

Definition at line 203 of file SkString.h.

{ this->insert((size_t)-1, text); }

append() [2/4]

void SkString::append ( const char  text[], size_t  len  )

inline

Definition at line 204 of file SkString.h.

{ this->insert((size_t)-1, text, len); }

append() [3/4]

void SkString::append ( const SkString &  str )

inline

Definition at line 205 of file SkString.h.

{ this->insert((size_t)-1, str.c_str(), str.size()); }

append() [4/4]

void SkString::append ( std::string_view  str )

inline

Definition at line 206 of file SkString.h.

{ this->insert((size_t)-1, str.data(), str.size()); }

appendf()

void SkString::appendf	(	const char	format[],
			...
	)

Definition at line 550 of file SkString.cpp.

                                               {
    va_list args;
    va_start(args, format);
    this->appendVAList(format, args);
    va_end(args);
}

appendHex()

void SkString::appendHex ( uint32_t  value, int  minDigits = 0  )

inline

Definition at line 212 of file SkString.h.

{ this->insertHex((size_t)-1, value, minDigits); }

appendS32()

void SkString::appendS32 ( int32_t  value )

inline

Definition at line 208 of file SkString.h.

{ this->insertS32((size_t)-1, value); }

appendS64()

void SkString::appendS64 ( int64_t  value, int  minDigits = 0  )

inline

Definition at line 209 of file SkString.h.

{ this->insertS64((size_t)-1, value, minDigits); }

appendScalar()

void SkString::appendScalar ( SkScalar  value )

inline

Definition at line 213 of file SkString.h.

{ this->insertScalar((size_t)-1, value); }

appendU32()

void SkString::appendU32 ( uint32_t  value )

inline

Definition at line 210 of file SkString.h.

{ this->insertU32((size_t)-1, value); }

appendU64()

void SkString::appendU64 ( uint64_t  value, int  minDigits = 0  )

inline

Definition at line 211 of file SkString.h.

{ this->insertU64((size_t)-1, value, minDigits); }

appendUnichar()

void SkString::appendUnichar ( SkUnichar  uni )

inline

Definition at line 207 of file SkString.h.

{ this->insertUnichar((size_t)-1, uni); }

appendVAList()

void SkString::appendVAList	(	const char	format[],
		va_list	args
	)

Definition at line 557 of file SkString.cpp.

                                                             {
    if (this->isEmpty()) {
        this->printVAList(format, args);
        return;
    }
 
    SkString overflow;
    char stackBuffer[kBufferSize];
    StringBuffer result = apply_format_string(format, args, stackBuffer, &overflow);
 
    this->append(result.fText, result.fLength);
}

c_str()

const char * SkString::c_str ( ) const

inline

Definition at line 133 of file SkString.h.

{ return fRec->data(); }

contains() [1/2]

bool SkString::contains ( const char  subchar ) const

inline

Definition at line 155 of file SkString.h.

                                            {
        return SkStrContains(fRec->data(), subchar);
    }

contains() [2/2]

bool SkString::contains ( const char  substring[] ) const

inline

Definition at line 152 of file SkString.h.

                                                {
        return SkStrContains(fRec->data(), substring);
    }

data() [1/2]

char * SkString::data

(

)

Definition at line 363 of file SkString.cpp.

                     {
    this->validate();
 
    if (fRec->fLength) {
        if (!fRec->unique()) {
            fRec = Rec::Make(fRec->data(), fRec->fLength);
        }
    }
    return fRec->data();
}

data() [2/2]

const char * SkString::data ( ) const

inline

Definition at line 132 of file SkString.h.

{ return fRec->data(); }

endsWith() [1/2]

bool SkString::endsWith ( const char  suffixChar ) const

inline

Definition at line 149 of file SkString.h.

                                               {
        return SkStrEndsWith(fRec->data(), suffixChar);
    }

endsWith() [2/2]

bool SkString::endsWith ( const char  suffixStr[] ) const

inline

Definition at line 146 of file SkString.h.

                                                {
        return SkStrEndsWith(fRec->data(), suffixStr);
    }

equals() [1/3]

bool SkString::equals

(

const char

text[]

)

const

Definition at line 328 of file SkString.cpp.

                                             {
    return this->equals(text, text ? strlen(text) : 0);
}

equals() [2/3]

bool SkString::equals	(	const char	text[],
		size_t	len
	)		const

Definition at line 332 of file SkString.cpp.

                                                         {
    SkASSERT(len == 0 || text != nullptr);
 
    return fRec->fLength == len && !sk_careful_memcmp(fRec->data(), text, len);
}

equals() [3/3]

bool SkString::equals

(

const SkString &

src

)

const

Definition at line 324 of file SkString.cpp.

                                               {
    return fRec == src.fRec || this->equals(src.c_str(), src.size());
}

find()

int SkString::find ( const char  substring[] ) const

inline

Definition at line 158 of file SkString.h.

                                           {
        return SkStrFind(fRec->data(), substring);
    }

findLastOf()

int SkString::findLastOf ( const char  subchar ) const

inline

Definition at line 161 of file SkString.h.

                                             {
        return SkStrFindLastOf(fRec->data(), subchar);
    }

insert() [1/4]

void SkString::insert	(	size_t	offset,
		const char	text[]
	)

Definition at line 415 of file SkString.cpp.

                                                      {
    this->insert(offset, text, text ? strlen(text) : 0);
}

insert() [2/4]

void SkString::insert	(	size_t	offset,
		const char	text[],
		size_t	len
	)

Definition at line 419 of file SkString.cpp.

                                                                  {
    if (len) {
        size_t length = fRec->fLength;
        if (offset > length) {
            offset = length;
        }
 
        // Check if length + len exceeds 32bits, we trim len
        len = check_add32(length, len);
        if (0 == len) {
            return;
        }
 
        /*  If we're the only owner, and we have room in our allocation for the insert,
            do it in place, rather than allocating a new buffer.
 
            To know we have room, compare the allocated sizes
            beforeAlloc = SkAlign4(length + 1)
            afterAlloc  = SkAligh4(length + 1 + len)
            but SkAlign4(x) is (x + 3) >> 2 << 2
            which is equivalent for testing to (length + 1 + 3) >> 2 == (length + 1 + 3 + len) >> 2
            and we can then eliminate the +1+3 since that doesn't affec the answer
        */
        if (fRec->unique() && (length >> 2) == ((length + len) >> 2)) {
            char* dst = this->data();
 
            if (offset < length) {
                memmove(dst + offset + len, dst + offset, length - offset);
            }
            memcpy(dst + offset, text, len);
 
            dst[length + len] = 0;
            fRec->fLength = SkToU32(length + len);
        } else {
            /*  Seems we should use realloc here, since that is safe if it fails
                (we have the original data), and might be faster than alloc/copy/free.
            */
            SkString    tmp(fRec->fLength + len);
            char*       dst = tmp.data();
 
            if (offset > 0) {
                memcpy(dst, fRec->data(), offset);
            }
            memcpy(dst + offset, text, len);
            if (offset < fRec->fLength) {
                memcpy(dst + offset + len, fRec->data() + offset,
                       fRec->fLength - offset);
            }
 
            this->swap(tmp);
        }
    }
}

insert() [3/4]

void SkString::insert ( size_t  offset, const SkString &  str  )

inline

Definition at line 193 of file SkString.h.

{ this->insert(offset, str.c_str(), str.size()); }

insert() [4/4]

void SkString::insert ( size_t  offset, std::string_view  str  )

inline

Definition at line 194 of file SkString.h.

{ this->insert(offset, str.data(), str.size()); }

insertHex()

void SkString::insertHex	(	size_t	offset,
		uint32_t	value,
		int	minDigits = 0
	)

Definition at line 506 of file SkString.cpp.

                                                                   {
    minDigits = SkTPin(minDigits, 0, 8);
 
    char    buffer[8];
    char*   p = buffer + sizeof(buffer);
 
    do {
        *--p = SkHexadecimalDigits::gUpper[hex & 0xF];
        hex >>= 4;
        minDigits -= 1;
    } while (hex != 0);
 
    while (--minDigits >= 0) {
        *--p = '0';
    }
 
    SkASSERT(p >= buffer);
    this->insert(offset, p, buffer + sizeof(buffer) - p);
}

insertS32()

void SkString::insertS32	(	size_t	offset,
		int32_t	value
	)

Definition at line 482 of file SkString.cpp.

                                                   {
    char    buffer[kSkStrAppendS32_MaxSize];
    char*   stop = SkStrAppendS32(buffer, dec);
    this->insert(offset, buffer, stop - buffer);
}

insertS64()

void SkString::insertS64	(	size_t	offset,
		int64_t	value,
		int	minDigits = 0
	)

Definition at line 488 of file SkString.cpp.

                                                                  {
    char    buffer[kSkStrAppendS64_MaxSize];
    char*   stop = SkStrAppendS64(buffer, dec, minDigits);
    this->insert(offset, buffer, stop - buffer);
}

insertScalar()

void SkString::insertScalar	(	size_t	offset,
		SkScalar	value
	)

Definition at line 526 of file SkString.cpp.

                                                         {
    char    buffer[kSkStrAppendScalar_MaxSize];
    char*   stop = SkStrAppendScalar(buffer, value);
    this->insert(offset, buffer, stop - buffer);
}

insertU32()

void SkString::insertU32	(	size_t	offset,
		uint32_t	value
	)

Definition at line 494 of file SkString.cpp.

                                                    {
    char    buffer[kSkStrAppendU32_MaxSize];
    char*   stop = SkStrAppendU32(buffer, dec);
    this->insert(offset, buffer, stop - buffer);
}

insertU64()

void SkString::insertU64	(	size_t	offset,
		uint64_t	value,
		int	minDigits = 0
	)

Definition at line 500 of file SkString.cpp.

                                                                   {
    char    buffer[kSkStrAppendU64_MaxSize];
    char*   stop = SkStrAppendU64(buffer, dec, minDigits);
    this->insert(offset, buffer, stop - buffer);
}

insertUnichar()

void SkString::insertUnichar	(	size_t	offset,
		SkUnichar	uni
	)

Definition at line 473 of file SkString.cpp.

                                                         {
    char    buffer[SkUTF::kMaxBytesInUTF8Sequence];
    size_t  len = SkUTF::ToUTF8(uni, buffer);
 
    if (len) {
        this->insert(offset, buffer, len);
    }
}

isEmpty()

bool SkString::isEmpty ( ) const

inline

Definition at line 130 of file SkString.h.

{ return 0 == fRec->fLength; }

operator+=() [1/3]

SkString & SkString::operator+= ( const char  c )

inline

Definition at line 236 of file SkString.h.

{ this->append(&c, 1); return *this; }

operator+=() [2/3]

SkString & SkString::operator+= ( const char  text[] )

inline

Definition at line 235 of file SkString.h.

{ this->append(text); return *this; }

operator+=() [3/3]

SkString & SkString::operator+= ( const SkString &  s )

inline

Definition at line 234 of file SkString.h.

{ this->append(s); return *this; }

operator=() [1/3]

SkString & SkString::operator=

(

const char

text[]

)

Definition at line 353 of file SkString.cpp.

                                               {
    this->validate();
    return *this = SkString(text);
}

operator=() [2/3]

SkString & SkString::operator=

(

const SkString &

src

)

Definition at line 338 of file SkString.cpp.

                                                 {
    this->validate();
    fRec = src.fRec;  // sk_sp<Rec>::operator=(const sk_sp<Ref>&) checks for self-assignment.
    return *this;
}

operator=() [3/3]

SkString & SkString::operator=

(

SkString &&

src

)

Definition at line 344 of file SkString.cpp.

                                            {
    this->validate();
 
    if (fRec != src.fRec) {
        this->swap(src);
    }
    return *this;
}

operator[]() [1/2]

char & SkString::operator[] ( size_t  n )

inline

Definition at line 179 of file SkString.h.

{ return this->data()[n]; }

operator[]() [2/2]

char SkString::operator[] ( size_t  n ) const

inline

Definition at line 134 of file SkString.h.

{ return this->c_str()[n]; }

prepend() [1/4]

void SkString::prepend ( const char  text[] )

inline

Definition at line 215 of file SkString.h.

{ this->insert(0, text); }

prepend() [2/4]

void SkString::prepend ( const char  text[], size_t  len  )

inline

Definition at line 216 of file SkString.h.

{ this->insert(0, text, len); }

prepend() [3/4]

void SkString::prepend ( const SkString &  str )

inline

Definition at line 217 of file SkString.h.

{ this->insert(0, str.c_str(), str.size()); }

prepend() [4/4]

void SkString::prepend ( std::string_view  str )

inline

Definition at line 218 of file SkString.h.

{ this->insert(0, str.data(), str.size()); }

prependf()

void SkString::prependf	(	const char	format[],
			...
	)

Definition at line 570 of file SkString.cpp.

                                                {
    va_list args;
    va_start(args, format);
    this->prependVAList(format, args);
    va_end(args);
}

prependHex()

void SkString::prependHex ( uint32_t  value, int  minDigits = 0  )

inline

Definition at line 222 of file SkString.h.

{ this->insertHex(0, value, minDigits); }

prependS32()

void SkString::prependS32 ( int32_t  value )

inline

Definition at line 220 of file SkString.h.

{ this->insertS32(0, value); }

prependS64()

void SkString::prependS64 ( int32_t  value, int  minDigits = 0  )

inline

Definition at line 221 of file SkString.h.

{ this->insertS64(0, value, minDigits); }

prependScalar()

void SkString::prependScalar ( SkScalar  value )

inline

Definition at line 223 of file SkString.h.

{ this->insertScalar((size_t)-1, value); }

prependUnichar()

void SkString::prependUnichar ( SkUnichar  uni )

inline

Definition at line 219 of file SkString.h.

{ this->insertUnichar(0, uni); }

prependVAList()

void SkString::prependVAList	(	const char	format[],
		va_list	args
	)

Definition at line 577 of file SkString.cpp.

                                                              {
    if (this->isEmpty()) {
        this->printVAList(format, args);
        return;
    }
 
    SkString overflow;
    char stackBuffer[kBufferSize];
    StringBuffer result = apply_format_string(format, args, stackBuffer, &overflow);
 
    this->prepend(result.fText, result.fLength);
}

printf()

void SkString::printf	(	const char	format[],
			...
	)

Definition at line 534 of file SkString.cpp.

                                              {
    va_list args;
    va_start(args, format);
    this->printVAList(format, args);
    va_end(args);
}

printVAList()

void SkString::printVAList	(	const char	format[],
		va_list	args
	)

Definition at line 541 of file SkString.cpp.

                                                            {
    char stackBuffer[kBufferSize];
    StringBuffer result = apply_format_string(format, args, stackBuffer, this);
 
    if (result.fText == stackBuffer) {
        this->set(result.fText, result.fLength);
    }
}

remove()

void SkString::remove	(	size_t	offset,
		size_t	length
	)

Definition at line 592 of file SkString.cpp.

                                                  {
    size_t size = this->size();
 
    if (offset < size) {
        if (length > size - offset) {
            length = size - offset;
        }
        SkASSERT(length <= size);
        SkASSERT(offset <= size - length);
        if (length > 0) {
            SkString    tmp(size - length);
            char*       dst = tmp.data();
            const char* src = this->c_str();
 
            if (offset) {
                memcpy(dst, src, offset);
            }
            size_t tail = size - (offset + length);
            if (tail) {
                memcpy(dst + offset, src + (offset + length), tail);
            }
            SkASSERT(dst[tmp.size()] == 0);
            this->swap(tmp);
        }
    }
}

reset()

void SkString::reset

(

)

Definition at line 358 of file SkString.cpp.

                     {
    this->validate();
    fRec.reset(const_cast<Rec*>(&gEmptyRec));
}

resize()

void SkString::resize

(

size_t

len

)

String contents are preserved on resize. (For destructive resize, set(nullptr, length).) resize automatically reserves an extra byte at the end of the buffer for a null terminator.

Definition at line 374 of file SkString.cpp.

                                {
    len = trim_size_t_to_u32(len);
    if (0 == len) {
        this->reset();
    } else if (fRec->unique() && ((len >> 2) <= (fRec->fLength >> 2))) {
        // Use less of the buffer we have without allocating a smaller one.
        char* p = this->data();
        p[len] = '\0';
        fRec->fLength = SkToU32(len);
    } else {
        SkString newString(len);
        char* dest = newString.data();
        int copyLen = std::min<uint32_t>(len, this->size());
        memcpy(dest, this->c_str(), copyLen);
        dest[copyLen] = '\0';
        this->swap(newString);
    }
}

set() [1/4]

void SkString::set

(

const char

text[]

)

Definition at line 393 of file SkString.cpp.

                                    {
    this->set(text, text ? strlen(text) : 0);
}

set() [2/4]

void SkString::set	(	const char	text[],
		size_t	len
	)

Definition at line 397 of file SkString.cpp.

                                                {
    len = trim_size_t_to_u32(len);
    if (0 == len) {
        this->reset();
    } else if (fRec->unique() && ((len >> 2) <= (fRec->fLength >> 2))) {
        // Use less of the buffer we have without allocating a smaller one.
        char* p = this->data();
        if (text) {
            memcpy(p, text, len);
        }
        p[len] = '\0';
        fRec->fLength = SkToU32(len);
    } else {
        SkString tmp(text, len);
        this->swap(tmp);
    }
}

set() [3/4]

void SkString::set ( const SkString &  src )

inline

Definition at line 186 of file SkString.h.

{ *this = src; }

set() [4/4]

void SkString::set ( std::string_view  str )

inline

Definition at line 189 of file SkString.h.

{ this->set(str.data(), str.size()); }

size()

size_t SkString::size ( ) const

inline

Definition at line 131 of file SkString.h.

{ return (size_t) fRec->fLength; }

startsWith() [1/2]

bool SkString::startsWith ( const char  prefixChar ) const

inline

Definition at line 143 of file SkString.h.

                                                 {
        return SkStrStartsWith(fRec->data(), prefixChar);
    }

startsWith() [2/2]

bool SkString::startsWith ( const char  prefixStr[] ) const

inline

Definition at line 140 of file SkString.h.

                                                  {
        return SkStrStartsWith(fRec->data(), prefixStr);
    }

swap()

void SkString::swap

(

SkString &

other

)

Swap contents between this and other. This function is guaranteed to never fail or throw.

Definition at line 619 of file SkString.cpp.

                                   {
    this->validate();
    other.validate();
 
    using std::swap;
    swap(fRec, other.fRec);
}

Friends And Related Function Documentation

operator!=

bool operator!= ( const SkString &  a, const SkString &  b  )

friend

Definition at line 168 of file SkString.h.

                                                                 {
        return !a.equals(b);
    }

operator==

bool operator== ( const SkString &  a, const SkString &  b  )

friend

Definition at line 165 of file SkString.h.

                                                                 {
        return a.equals(b);
    }

---

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

• third_party/skia/include/core/SkString.h
• third_party/skia/src/core/SkString.cpp