SkStringUtils.h File Reference

#include "include/core/SkScalar.h"
#include "include/core/SkString.h"
#include "include/private/base/SkTArray.h"
#include <cstddef>
#include <cstdint>

Go to the source code of this file.

Macros
#define	SK_strcasecmp   strcasecmp

Enumerations
enum	SkScalarAsStringType { kDec_SkScalarAsStringType , kHex_SkScalarAsStringType }
enum	SkStrSplitMode { kStrict_SkStrSplitMode , kCoalesce_SkStrSplitMode }

Functions
void	SkAppendScalar (SkString *, SkScalar, SkScalarAsStringType)
static void	SkAppendScalarDec (SkString *str, SkScalar value)
static void	SkAppendScalarHex (SkString *str, SkScalar value)
SkString	SkTabString (const SkString &string, int tabCnt)
SkString	SkStringFromUTF16 (const uint16_t *src, size_t count)
void	SkStrSplit (const char *str, const char *delimiters, SkStrSplitMode splitMode, skia_private::TArray< SkString > *out)
void	SkStrSplit (const char *str, const char *delimiters, skia_private::TArray< SkString > *out)

Macro Definition Documentation

SK_strcasecmp

#define SK_strcasecmp   strcasecmp

Definition at line 41 of file SkStringUtils.h.

Enumeration Type Documentation

SkScalarAsStringType

enum SkScalarAsStringType

Enumerator
kDec_SkScalarAsStringType
kHex_SkScalarAsStringType

Definition at line 18 of file SkStringUtils.h.

                          {
    kDec_SkScalarAsStringType,
    kHex_SkScalarAsStringType,
};

SkStrSplitMode

enum SkStrSplitMode

Enumerator
kStrict_SkStrSplitMode
kCoalesce_SkStrSplitMode

Definition at line 44 of file SkStringUtils.h.

                    {
    // Strictly return all results. If the input is ",," and the separator is ',' this will return
    // an array of three empty strings.
    kStrict_SkStrSplitMode,
 
    // Only nonempty results will be added to the results. Multiple separators will be
    // coalesced. Separators at the beginning and end of the input will be ignored.  If the input is
    // ",," and the separator is ',', this will return an empty vector.
    kCoalesce_SkStrSplitMode
};

Function Documentation

SkAppendScalar()

void SkAppendScalar	(	SkString *	str,
		SkScalar	value,
		SkScalarAsStringType	asType
	)

Definition at line 20 of file SkStringUtils.cpp.

                                                                                {
    switch (asType) {
        case kHex_SkScalarAsStringType:
            str->appendf("SkBits2Float(0x%08x)", SkFloat2Bits(value));
            break;
        case kDec_SkScalarAsStringType: {
            SkString tmp;
            tmp.printf("%.9g", value);
            if (tmp.contains('.')) {
                tmp.appendUnichar('f');
            }
            str->append(tmp);
            break;
        }
    }
}

SkAppendScalarDec()

static void SkAppendScalarDec ( SkString *  str, SkScalar  value  )

inlinestatic

Definition at line 25 of file SkStringUtils.h.

                                                                    {
    SkAppendScalar(str, value, kDec_SkScalarAsStringType);
}

SkAppendScalarHex()

static void SkAppendScalarHex ( SkString *  str, SkScalar  value  )

inlinestatic

Definition at line 29 of file SkStringUtils.h.

                                                                    {
    SkAppendScalar(str, value, kHex_SkScalarAsStringType);
}

SkStringFromUTF16()

SkString SkStringFromUTF16	(	const uint16_t *	src,
		size_t	count
	)

Definition at line 64 of file SkStringUtils.cpp.

                                                              {
    SkString ret;
    const uint16_t* stop = src + count;
    if (count > 0) {
        SkASSERT(src);
        size_t n = 0;
        const uint16_t* end = src + count;
        for (const uint16_t* ptr = src; ptr < end;) {
            const uint16_t* last = ptr;
            SkUnichar u = SkUTF::NextUTF16(&ptr, stop);
            size_t s = SkUTF::ToUTF8(u);
            if (n > UINT32_MAX - s) {
                end = last;  // truncate input string
                break;
            }
            n += s;
        }
        ret = SkString(n);
        char* out = ret.data();
        for (const uint16_t* ptr = src; ptr < end;) {
            out += SkUTF::ToUTF8(SkUTF::NextUTF16(&ptr, stop), out);
        }
        SkASSERT(out == ret.data() + n);
    }
    return ret;
}

SkStrSplit() [1/2]

void SkStrSplit ( const char *  str, const char *  delimiters, skia_private::TArray< SkString > *  out  )

inline

Definition at line 61 of file SkStringUtils.h.

                                                                                    {
    SkStrSplit(str, delimiters, kCoalesce_SkStrSplitMode, out);
}

SkStrSplit() [2/2]

void SkStrSplit	(	const char *	str,
		const char *	delimiters,
		SkStrSplitMode	splitMode,
		skia_private::TArray< SkString > *	out
	)

Definition at line 91 of file SkStringUtils.cpp.

                                       {
    if (splitMode == kCoalesce_SkStrSplitMode) {
        // Skip any delimiters.
        str += strspn(str, delimiters);
    }
    if (!*str) {
        return;
    }
 
    while (true) {
        // Find a token.
        const size_t len = strcspn(str, delimiters);
        if (splitMode == kStrict_SkStrSplitMode || len > 0) {
            out->push_back().set(str, len);
            str += len;
        }
 
        if (!*str) {
            return;
        }
        if (splitMode == kCoalesce_SkStrSplitMode) {
            // Skip any delimiters.
            str += strspn(str, delimiters);
        } else {
            // Skip one delimiter.
            str += 1;
        }
    }
}

SkTabString()

SkString SkTabString	(	const SkString &	string,
		int	tabCnt
	)

Indents every non-empty line of the string by tabCnt tabs

Definition at line 37 of file SkStringUtils.cpp.

                                                         {
    if (tabCnt <= 0) {
        return string;
    }
    SkString tabs;
    for (int i = 0; i < tabCnt; ++i) {
        tabs.append("\t");
    }
    SkString result;
    static const char newline[] = "\n";
    const char* input = string.c_str();
    int nextNL = SkStrFind(input, newline);
    while (nextNL >= 0) {
        if (nextNL > 0) {
            result.append(tabs);
        }
        result.append(input, nextNL + 1);
        input += nextNL + 1;
        nextNL = SkStrFind(input, newline);
    }
    if (*input != '\0') {
        result.append(tabs);
        result.append(input);
    }
    return result;
}