/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 30 авг. 2017 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #ifndef LSP_PLUG_IN_RUNTIME_LSPSTRING_H_ #define LSP_PLUG_IN_RUNTIME_LSPSTRING_H_ #include #include #include #include #include #include namespace lsp { /** * String class */ class LSPString { protected: typedef struct buffer_t { size_t nOffset; size_t nLength; char *pData; } buffer_t; protected: size_t nLength; size_t nCapacity; lsp_wchar_t *pData; mutable size_t nHash; mutable buffer_t *pTemp; protected: bool size_reserve(size_t size); inline bool cap_reserve(size_t size); inline bool cap_grow(size_t delta); void drop_temp(); bool append_temp(const char *p, size_t n) const; bool resize_temp(size_t n) const; bool grow_temp(size_t n) const; static inline lsp_wchar_t *xmalloc(size_t size) { return reinterpret_cast(::malloc(size * sizeof(lsp_wchar_t))); } static inline lsp_wchar_t *xrealloc(lsp_wchar_t * ptr, size_t size) { return reinterpret_cast(::realloc(ptr, size * sizeof(lsp_wchar_t))); }; static inline void xfree(lsp_wchar_t *ptr) { ::free(ptr); } static inline void xmove(lsp_wchar_t *dst, const lsp_wchar_t *src, size_t n) { ::memmove(dst, src, n * sizeof(lsp_wchar_t)); } static inline size_t xlen(const lsp_wchar_t *s); static inline size_t u16len(const lsp_utf16_t *s); #ifdef ARCH_LE static inline int xcmp(const lsp_wchar_t *a, const lsp_wchar_t *b, size_t n) { return ::memcmp(a, b, n * sizeof(lsp_wchar_t)); } #else static int xcmp(const lsp_wchar_t *a, const lsp_wchar_t *b, size_t n); #endif /* ARCH_LE */ static int xcasecmp(const lsp_wchar_t *a, const lsp_wchar_t *b, size_t n); static inline void acopy(lsp_wchar_t *dst, const char *src, size_t n); public: explicit LSPString(); ~LSPString(); public: /** Get the length of the string * * @return the length of the string */ inline size_t length() const { return nLength; } /** * Get the length of the range * @param first the index of first character * @param last the index of last character * @return final length of the range */ size_t range_length(ssize_t first, ssize_t last) const; /** * Set the length of the string, allows only to cut data from tail * @param length the length of the string * @return the length of the string after applied operarion */ size_t set_length(size_t length); /** Get the capacity of the string * * @return capacity of the string */ inline size_t capacity() const { return nCapacity; } /** Check whether the string is emtpy * * @return true if string is empty */ inline bool is_empty() const { return nLength <= 0; } /** Get pointer to internal non-zero-terminated characters array * This method is unsafe and is provided only for low-level optimizations * You should know what you're doing when calling this method * * @return pointer to internal to internal non-null-terminated characters array */ inline const lsp_wchar_t *characters() const { return pData; } /** Reserve additional capacity at the tail for further modifications * * @param size number of characters to use as capacity * @return true on success */ inline bool reserve(size_t size) { return (size > nCapacity) ? size_reserve(size) : true; }; /** * Clear the string without deallocating internal buffer */ void clear(); /** Truncate the string (and remove extra capacity) * */ void truncate(); bool truncate(size_t size); /** Try to reduce memory allocated by the string (remove extra capacity) * */ void reduce(); /** * Trim spaces at the start of line and at the end of line */ void trim(); /** Swap internal contents with other string * * @param src string to perform the swap */ void swap(LSPString *src); inline void swap(LSPString &src) { swap(&src); } /** Swap two characters * * @param idx1 character at first position * @param idx2 character at second position * @return true on success */ bool swap(ssize_t idx1, ssize_t idx2); /** Take data from another string and empty that string * * @param src source string */ void take(LSPString *src); void take(LSPString &src); /** Give data to another string and empty self * * @param dst target string */ inline void give(LSPString *dst) { dst->take(this); } /** Copy this string * * @return copy of the string or NULL on error */ LSPString *copy() const; LSPString *copy(ssize_t first) const; LSPString *copy(ssize_t first, ssize_t last) const; inline LSPString *clone() const { return copy(); } inline LSPString *clone(ssize_t first) const { return copy(first); } inline LSPString *clone(ssize_t first, ssize_t last) const { return copy(first, last); } /** Allocate instance of string and drain self data to this instance * * @return not null pointer is there is enough memory */ LSPString *release(); /** Insert data at specified position * * @param pos position * @param ch character to insert * @return true on success */ bool insert(ssize_t pos, lsp_wchar_t ch); /** Insert character data at specified position * * @param pos position * @param arr array of characters to insert * @param n number of characters in array * @return true on success */ bool insert(ssize_t pos, const lsp_wchar_t *arr, ssize_t n); /** Insert string at specified position * * @param pos position * @param src source string to insert * @return true on success */ bool insert(ssize_t pos, const LSPString *src); /** Insert substring at specified position * * @param pos position * @param src source string to use substring for insert * @param first index of first character to use as sub-string of the source string * @return true on success */ bool insert(ssize_t pos, const LSPString *src, ssize_t first); /** Insert substring at specified position * * @param pos position * @param src source string to use substring for insert * @param first index of first character to use as sub-string of the source string * @param last index of last character to use as sub-string of the source string * @return true on success */ bool insert(ssize_t pos, const LSPString *src, ssize_t first, ssize_t last); /** Append data at the tail of string * * @param ch ASCII character to append * @return true on success */ bool append(char ch); /** Append data at the tail of string * * @param ch character to append * @return true on success */ bool append(lsp_wchar_t ch); /** Append data at the tail of string * * @param ch character to append * @return true on success */ bool append(lsp_swchar_t ch); bool append_ascii(const char *arr, size_t n); bool append_utf8(const char *arr, size_t n); bool append_utf16(const lsp_utf16_t *arr, size_t n); bool append(const lsp_wchar_t *arr, size_t n); bool append(const lsp_wchar_t *arr); bool append(const LSPString *src); bool append(const LSPString *src, ssize_t first); bool append(const LSPString *src, ssize_t first, ssize_t last); inline bool append_ascii(const char *arr) { return append_ascii(arr, ::strlen(arr)); }; inline bool append_utf8(const char *arr) { return append_utf8(arr, ::strlen(arr)); }; bool append_utf16(const lsp_utf16_t *arr); bool prepend(lsp_wchar_t ch); bool prepend(const lsp_wchar_t *arr, size_t n); bool prepend_utf8(const char *arr, size_t n); bool prepend_ascii(const char *arr, size_t n); bool prepend(const LSPString *src); bool prepend(const LSPString *src, ssize_t first); bool prepend(const LSPString *src, ssize_t first, ssize_t last); inline bool prepend_ascii(const char *arr) { return prepend_ascii(arr, ::strlen(arr)); }; inline bool prepend_utf8(const char *arr) { return prepend_utf8(arr, ::strlen(arr)); }; /** Get unicode character at the specified position * * @param index index * @return character or 0 on error */ lsp_wchar_t at(ssize_t index) const; lsp_wchar_t char_at(ssize_t index) const { return at(index); } /** * Get first character * @return first character on 0 on error */ lsp_wchar_t first() const; /** * Get last character * @return last character on 0 on error */ lsp_wchar_t last() const; /** Reverse the order of characters * */ void reverse(); /** Shuffle characters * */ void shuffle(); bool set(lsp_wchar_t ch); inline bool set(char ch) { return set(lsp_wchar_t(uint8_t(ch))); }; bool set(ssize_t pos, lsp_wchar_t ch); inline bool set_at(ssize_t pos, lsp_wchar_t ch) { return set(pos, ch); } bool set(const lsp_wchar_t *arr); bool set(const lsp_wchar_t *arr, size_t n); /** Copy contents from another string * @param src source string */ bool set(const LSPString *src); /** Copy contents from substring of another string * @param src source string * @param first the first character of source substring */ bool set(const LSPString *src, ssize_t first); /** Copy contents from substring of another string * @param src source string to obtain a substring * @param first the first character of source substring * @param last the last character of source substring */ bool set(const LSPString *src, ssize_t first, ssize_t last); /** Different conversion routines * * @param s pointer to UTF-8 string * @param n number of octets in the string * @return true on success */ bool set_utf8(const char *s, size_t n); inline bool set_utf8(const char *s) { return set_utf8(s, ::strlen(s)); }; bool set_utf16(const lsp_utf16_t *s, size_t n); bool set_utf16(const lsp_utf16_t *s); bool set_utf16le(const lsp_utf16_t *s, size_t n); bool set_utf16le(const lsp_utf16_t *s); bool set_utf16be(const lsp_utf16_t *s, size_t n); bool set_utf16be(const lsp_utf16_t *s); bool set_ascii(const char *s, size_t n); inline bool set_ascii(const char *s) { return set_ascii(s, ::strlen(s)); }; bool set_native(const char *s, size_t n, const char *charset = NULL); inline bool set_native(const char *s, const char *charset) { return set_native(s, ::strlen(s), charset); }; inline bool set_native(const char *s) { return set_native(s, ::strlen(s), NULL); }; const char *get_utf8(ssize_t first, ssize_t last) const; inline const char *get_utf8(ssize_t first) const { return get_utf8(first, nLength); }; const char *get_utf8() const { return get_utf8(0, nLength); }; const lsp_utf16_t *get_utf16(ssize_t first, ssize_t last) const; inline const lsp_utf16_t *get_utf16(ssize_t first) const { return get_utf16(first, nLength); }; inline const lsp_utf16_t *get_utf16() const { return get_utf16(0, nLength); }; const lsp_utf16_t *get_utf16le(ssize_t first, ssize_t last) const; inline const lsp_utf16_t *get_utf16le(ssize_t first) const { return get_utf16le(first, nLength); }; inline const lsp_utf16_t *get_utf16le() const { return get_utf16le(0, nLength); }; const lsp_utf16_t *get_utf16be(ssize_t first, ssize_t last) const; inline const lsp_utf16_t *get_utf16be(ssize_t first) const { return get_utf16be(first, nLength); }; inline const lsp_utf16_t *get_utf16be() const { return get_utf16be(0, nLength); }; const char *get_ascii(ssize_t first, ssize_t last) const; inline const char *get_ascii(ssize_t first) const { return get_ascii(first, nLength); }; inline const char *get_ascii() const { return get_ascii(0, nLength); }; const char *get_native(ssize_t first, ssize_t last, const char *charset = NULL) const; inline const char *get_native(const char *charset = NULL) const { return get_native(0, nLength, charset); } inline const char *get_native(ssize_t first, const char *charset = NULL) const { return get_native(first, nLength, charset); } inline size_t temporal_size() const { return (pTemp != NULL) ? pTemp->nOffset : 0; }; inline size_t temporal_capacity() const { return (pTemp != NULL) ? pTemp->nLength : 0; }; /** * Find number of matching characters from one string to another */ size_t match(const LSPString *s, size_t index) const; inline size_t match(const LSPString *s) const { return match(s, 0); } size_t match_nocase(const LSPString *s, size_t index) const; inline size_t match_nocase(const LSPString *s) const { return match_nocase(s, 0); } /** * Clone string as set of UTF-8 characters. 1 character at the tail will contain additional end-of-line. */ char *clone_utf8(size_t *bytes, ssize_t first, ssize_t last) const; inline char *clone_utf8(size_t *bytes, ssize_t first) const { return clone_utf8(bytes, first, nLength); }; inline char *clone_utf8(size_t *bytes) const { return clone_utf8(bytes, 0, nLength); }; inline char *clone_utf8(ssize_t first, ssize_t last) const { return clone_utf8(NULL, first, last); }; inline char *clone_utf8(ssize_t first) const { return clone_utf8(NULL, first, nLength); }; inline char *clone_utf8() const { return clone_utf8(NULL, 0, nLength); }; /** * Clone string as set of UTF-16 characters. 1 UTF-16 character at the tail will contain additional end-of-line. */ lsp_utf16_t *clone_utf16(size_t *bytes, ssize_t first, ssize_t last) const; inline lsp_utf16_t *clone_utf16(size_t *bytes, ssize_t first) const { return clone_utf16(bytes, first, nLength); }; inline lsp_utf16_t *clone_utf16(size_t *bytes) const { return clone_utf16(bytes, 0, nLength); }; inline lsp_utf16_t *clone_utf16(ssize_t first, ssize_t last) const { return clone_utf16(NULL, first, last); }; inline lsp_utf16_t *clone_utf16(ssize_t first) const { return clone_utf16(NULL, first, nLength); }; inline lsp_utf16_t *clone_utf16() const { return clone_utf16(NULL, 0, nLength); }; lsp_utf16_t *clone_utf16le(size_t *bytes, ssize_t first, ssize_t last) const; inline lsp_utf16_t *clone_utf16le(size_t *bytes, ssize_t first) const { return clone_utf16le(bytes, first, nLength); }; inline lsp_utf16_t *clone_utf16le(size_t *bytes) const { return clone_utf16le(bytes, 0, nLength); }; inline lsp_utf16_t *clone_utf16le(ssize_t first, ssize_t last) const { return clone_utf16le(NULL, first, last); }; inline lsp_utf16_t *clone_utf16le(ssize_t first) const { return clone_utf16le(NULL, first, nLength); }; inline lsp_utf16_t *clone_utf16le() const { return clone_utf16le(NULL, 0, nLength); }; lsp_utf16_t *clone_utf16be(size_t *bytes, ssize_t first, ssize_t last) const; inline lsp_utf16_t *clone_utf16be(size_t *bytes, ssize_t first) const { return clone_utf16be(bytes, first, nLength); }; inline lsp_utf16_t *clone_utf16be(size_t *bytes) const { return clone_utf16be(bytes, 0, nLength); }; inline lsp_utf16_t *clone_utf16be(ssize_t first, ssize_t last) const { return clone_utf16be(NULL, first, last); }; inline lsp_utf16_t *clone_utf16be(ssize_t first) const { return clone_utf16be(NULL, first, nLength); }; inline lsp_utf16_t *clone_utf16be() const { return clone_utf16be(NULL, 0, nLength); }; /** * Clone string as set of UTF-16 characters. 1 ascii character at the tail will contain additional end-of-line. */ char *clone_ascii(size_t *bytes, ssize_t first, ssize_t last) const; inline char *clone_ascii(size_t *bytes, ssize_t first) const { return clone_ascii(bytes, first, nLength); }; inline char *clone_ascii(size_t *bytes) const { return clone_ascii(bytes, 0, nLength); }; inline char *clone_ascii(ssize_t first, ssize_t last) const { return clone_ascii(NULL, first, last); }; inline char *clone_ascii(ssize_t first) const { return clone_ascii(NULL, first, nLength); }; inline char *clone_ascii() const { return clone_ascii(NULL, 0, nLength); }; /** * Clone string as set of UTF-16 characters. 4 ascii characters at the tail will contain additional end-of-line. */ char *clone_native(size_t *bytes, ssize_t first, ssize_t last, const char *charset = NULL) const; inline char *clone_native(size_t *bytes, ssize_t first, const char *charset = NULL) const { return clone_native(bytes, first, nLength, charset); } inline char *clone_native(size_t *bytes, const char *charset = NULL) const { return clone_native(bytes, 0, nLength, charset); } inline char *clone_native(ssize_t first, ssize_t last, const char *charset = NULL) const { return clone_native(NULL, first, last, charset); } inline char *clone_native(const char *charset = NULL) const { return clone_native(NULL, 0, nLength, charset); } inline char *clone_native(ssize_t first, const char *charset = NULL) const { return clone_native(NULL, first, nLength, charset); } /** Replace the contents of the string * */ bool replace(ssize_t pos, lsp_wchar_t ch); bool replace(ssize_t pos, const lsp_wchar_t *arr, size_t n); bool replace(ssize_t pos, const LSPString *src); bool replace(ssize_t pos, const LSPString *src, ssize_t start); bool replace(ssize_t pos, const LSPString *src, ssize_t first, ssize_t last); bool replace(ssize_t first, ssize_t last, lsp_wchar_t ch); bool replace(ssize_t first, ssize_t last, const lsp_wchar_t *arr, size_t n); bool replace(ssize_t first, ssize_t last, const LSPString *src); bool replace(ssize_t first, ssize_t last, const LSPString *src, ssize_t sfirst); bool replace(ssize_t first, ssize_t last, const LSPString *src, ssize_t sfirst, ssize_t slast); /** * Replace all characters in the string with the replacement * @param ch character to replace * @param rep replacement character * @return number of replacements */ size_t replace_all(lsp_wchar_t ch, lsp_wchar_t rep); inline size_t replace_all(char ch, char rep) { return replace_all(lsp_wchar_t(uint8_t(ch)), lsp_wchar_t(uint8_t(rep))); }; inline size_t replace_all(char ch, lsp_wchar_t rep) { return replace_all(lsp_wchar_t(uint8_t(ch)), rep); }; inline size_t replace_all(lsp_wchar_t ch, char rep) { return replace_all(ch, lsp_wchar_t(uint8_t(rep))); }; /** Check ending of the string * */ bool ends_with(lsp_wchar_t ch) const; inline bool ends_with(char ch) const { return ends_with(lsp_wchar_t(uint8_t(ch))); }; bool ends_with(const LSPString *src) const; bool ends_with_ascii(const char *src) const; bool ends_with_ascii_nocase(const char *src) const; bool ends_with_nocase(lsp_wchar_t ch) const; inline bool ends_with_nocase(char ch) const { return ends_with_nocase(lsp_wchar_t(uint8_t(ch))); }; bool ends_with_nocase(const LSPString *src) const; /** * Check that string starts with specified character * @param ch character to check * @param offset the offset to the beginning of the string * @return true if string starts with specified character */ bool starts_with(lsp_wchar_t ch, size_t offset) const; /** * Check that string starts with specified character * @param ch character to check * @return true if string starts with specified character */ bool starts_with(lsp_wchar_t ch) const { return starts_with(ch, 0); }; inline bool starts_with(char ch) const { return starts_with(lsp_wchar_t(uint8_t(ch)), 0); }; inline bool starts_with(char ch, size_t offset) const { return starts_with(lsp_wchar_t(uint8_t(ch)), offset); }; bool starts_with(const LSPString *src, size_t offset) const; inline bool starts_with(const LSPString *src) const { return starts_with(src, 0); }; bool starts_with_ascii(const char *src, size_t offset) const; inline bool starts_with_ascii(const char *src) const { return starts_with_ascii(src, 0); }; bool starts_with_nocase(lsp_wchar_t ch, size_t offset) const; bool starts_with_nocase(lsp_wchar_t ch) const { return starts_with(ch, 0); }; inline bool starts_with_nocase(char ch) const { return starts_with_nocase(lsp_wchar_t(uint8_t(ch)), 0); }; inline bool starts_with_nocase(char ch, size_t offset) const{ return starts_with_nocase(lsp_wchar_t(uint8_t(ch)), offset); }; bool starts_with_nocase(const LSPString *src, size_t offset) const; inline bool starts_with_nocase(const LSPString *src) const { return starts_with_nocase(src, 0); }; bool starts_with_ascii_nocase(const char *src, size_t offset) const; inline bool starts_with_ascii_nocase(const char *src) const { return starts_with_ascii_nocase(src, 0); }; /** Delete character sequence from the string * */ bool remove(); bool remove(ssize_t first); bool remove(ssize_t first, ssize_t last); bool remove_last(); /** Try to find substring in a string * * @param start start location to begin search * @param str string to search * @return index of character or negative value */ ssize_t index_of(ssize_t start, const LSPString *str) const; ssize_t index_of(const LSPString *str) const; ssize_t rindex_of(ssize_t start, const LSPString *str) const; ssize_t rindex_of(const LSPString *str) const; ssize_t index_of(ssize_t start, lsp_wchar_t ch) const; inline ssize_t index_of(ssize_t start, char ch) const { return index_of(start, lsp_wchar_t(uint8_t(ch))); }; ssize_t index_of(lsp_wchar_t ch) const; inline ssize_t index_of(char ch) const { return index_of(lsp_wchar_t(uint8_t(ch))); }; ssize_t rindex_of(ssize_t start, lsp_wchar_t ch) const; inline ssize_t rindex_of(ssize_t start, char ch) const { return rindex_of(start, lsp_wchar_t(uint8_t(ch))); }; ssize_t rindex_of(lsp_wchar_t ch) const; inline ssize_t rindex_of(char ch) const { return rindex_of(lsp_wchar_t(uint8_t(ch))); }; ssize_t index_of_nocase(ssize_t start, const LSPString *str) const; ssize_t index_of_nocase(const LSPString *str) const; ssize_t rindex_of_nocase(ssize_t start, const LSPString *str) const; ssize_t rindex_of_nocase(const LSPString *str) const; ssize_t index_of_nocase(ssize_t start, lsp_wchar_t ch) const; inline ssize_t index_of_nocase(ssize_t start, char ch) const { return index_of_nocase(start, lsp_wchar_t(uint8_t(ch))); }; ssize_t index_of_nocase(lsp_wchar_t ch) const; inline ssize_t index_of_nocase(char ch) const { return index_of_nocase(lsp_wchar_t(uint8_t(ch))); }; ssize_t rindex_of_nocase(ssize_t start, lsp_wchar_t ch) const; inline ssize_t rindex_of_nocase(ssize_t start, char ch) const { return rindex_of_nocase(start, lsp_wchar_t(uint8_t(ch))); }; ssize_t rindex_of_nocase(lsp_wchar_t ch) const; inline ssize_t rindex_of_nocase(char ch) const { return rindex_of_nocase(lsp_wchar_t(uint8_t(ch))); }; /** * Produce new object as substring of a string * @param first index of first character for a substring * @return pointer to substring or NULL on error */ LSPString *substring(ssize_t first) const; /** * Produce new object as substring of a string * @param first index of first character for a substring * @param last index of last character for a substring * @return pointer to substring or NULL on error */ LSPString *substring(ssize_t first, ssize_t last) const; /** Compare to another string * * @param src string to compare to * @return result of comparison */ int compare_to(const lsp_wchar_t *src) const; int compare_to(const lsp_wchar_t *src, size_t n) const; inline int compare_to(const LSPString *src) const { return compare_to(src->pData, src->nLength); }; int compare_to_ascii(const char *src) const; int compare_to_utf8(const char *src) const; int compare_to_utf16(const lsp_utf16_t *src) const; int compare_to_nocase(const lsp_wchar_t *src) const; int compare_to_nocase(const lsp_wchar_t *src, size_t n) const; inline int compare_to_nocase(const LSPString *src) const { return compare_to_nocase(src->pData, src->nLength); }; int compare_to_ascii_nocase(const char *src) const; int compare_to_utf8_nocase(const char *src) const; int compare_to_utf16_nocase(const lsp_utf16_t *src) const; size_t tolower(); size_t tolower(ssize_t first); size_t tolower(ssize_t first, ssize_t last); size_t toupper(); size_t toupper(ssize_t first); size_t toupper(ssize_t first, ssize_t last); /** Check that string equals * * @param src string to compare * @return true if equals */ bool equals(const lsp_wchar_t *src) const; bool equals(const lsp_wchar_t *src, size_t len) const; inline bool equals(const LSPString *src) const { return equals(src->pData, src->nLength); }; bool equals(const LSPString *src, ssize_t first, ssize_t last) const; bool equals_nocase(const lsp_wchar_t *src) const; bool equals_nocase(const lsp_wchar_t *src, size_t len) const; inline bool equals_nocase(const LSPString *src) const { return equals_nocase(src->pData, src->nLength); }; inline bool equals_ascii(const char *src) const { return compare_to_ascii(src) == 0; }; inline bool equals_ascii_nocase(const char *src) const { return compare_to_ascii_nocase(src) == 0; }; inline bool equals_utf8(const char *src) const { return compare_to_utf8(src) == 0; }; inline bool equals_utf8_nocase(const char *src) const { return compare_to_utf8_nocase(src) == 0; }; inline bool equals_utf16(const lsp_utf16_t *src) const { return compare_to_utf16(src) == 0; }; inline bool equals_utf16_nocase(const lsp_utf16_t *src) const { return compare_to_utf16_nocase(src) == 0; }; bool contains_at(ssize_t index, const lsp_wchar_t *src) const; bool contains_at(ssize_t index, const lsp_wchar_t *src, size_t len) const; inline bool contains_at(ssize_t index, const LSPString *src) const { return contains_at(index, src->pData, src->nLength); }; bool contains_at_ascii(ssize_t index, const char *src) const; bool contains_at_utf8(ssize_t index, const char *src) const; bool contains_at_utf16(ssize_t index, const lsp_utf16_t *src) const; /** Calculate number of character occurences * * @param ch character * @return number of character occurences */ size_t count(lsp_wchar_t ch) const; size_t count(lsp_wchar_t ch, ssize_t first) const; size_t count(lsp_wchar_t ch, ssize_t first, ssize_t last) const; /** * Formatting functions, internally asprintf functin is used */ ssize_t fmt_append_native(const char *fmt...); ssize_t fmt_preend_native(const char *fmt...); ssize_t fmt_native(const char *fmt...); ssize_t vfmt_append_native(const char *fmt, va_list args); ssize_t vfmt_preend_native(const char *fmt, va_list args); ssize_t vfmt_native(const char *fmt, va_list args); ssize_t fmt_append_ascii(const char *fmt...); ssize_t fmt_prepend_ascii(const char *fmt...); ssize_t fmt_ascii(const char *fmt...); ssize_t vfmt_append_ascii(const char *fmt, va_list args); ssize_t vfmt_prepend_ascii(const char *fmt, va_list args); ssize_t vfmt_ascii(const char *fmt, va_list args); ssize_t fmt_append_utf8(const char *fmt...); ssize_t fmt_prepend_utf8(const char *fmt...); ssize_t fmt_utf8(const char *fmt...); ssize_t vfmt_append_utf8(const char *fmt, va_list args); ssize_t vfmt_prepend_utf8(const char *fmt, va_list args); ssize_t vfmt_utf8(const char *fmt, va_list args); /** * Compute the hash code * @return hash code */ size_t hash() const; /** * Convert line endings * @return true if the conversion has succeeded */ bool to_dos(); bool to_unix(); }; // LLTL specialization for String class namespace lltl { // Non-const specifications template <> struct hash_spec: public hash_iface { static size_t hash_func(const void *ptr, size_t size); explicit hash_spec() { hash = hash_func; } }; template <> struct compare_spec: public compare_iface { static ssize_t cmp_func(const void *a, const void *b, size_t size); explicit compare_spec() { compare = cmp_func; } }; template <> struct allocator_spec: public allocator_iface { static void *clone_func(const void *src, size_t size); static void free_func(void *ptr); explicit allocator_spec() { clone = clone_func; free = free_func; } }; // Const specifications template <> struct hash_spec: public hash_iface { static size_t hash_func(const void *ptr, size_t size); explicit hash_spec() { hash = hash_func; } }; template <> struct compare_spec: public compare_iface { static ssize_t cmp_func(const void *a, const void *b, size_t size); explicit compare_spec() { compare = cmp_func; } }; template <> struct allocator_spec: public allocator_iface { static void *clone_func(const void *src, size_t size); static void free_func(void *ptr); explicit allocator_spec() { clone = clone_func; free = free_func; } }; } /* namespace lltl */ } /* namespace lsp */ #endif /* LSP_PLUG_IN_RUNTIME_LSPSTRING_H_ */