string.h

/*
 * Copyright regify
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#ifndef REGIFY_UTIL_STRING_H
#define REGIFY_UTIL_STRING_H
/* Only need to export C interface if used by C++ source code */
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
typedef void* ruString;
RUAPI ruString ruStringNew(const char* instr);
 
RUAPI ruString ruStringNewn(const char* instr, rusize size);
 
RUAPI ruString ruStringNewf(const char* format, ...);
 
RUAPI int32_t ruStringReset(ruString rs);
 
RUAPI ruString ruStringFree(ruString rs, bool keepBuffer);
 
RUAPI int32_t ruStringAppend(ruString rs, const char* str);
 
RUAPI int32_t ruStringAppendUriEncoded(ruString rs, const char* instr);
 
RUAPI int32_t ruStringAppendn(ruString rs, const char* instr, rusize len);
 
RUAPI int32_t ruStringAppendf(ruString rs, const char* format, ...);
 
RUAPI char* ruStringGetCString(ruString rs);
 
RUAPI rusize ruStringLen(ruString rs, int32_t *code);
 
RUAPI bool ruStringEndsWith(ruString rs, const char *suffix, int32_t *code);
#define ruUtf8Nfc 1
 
#define ruUtf8Nfd 2
// these seem to be generally missing ATM
//#define ruUtf8Nfkc 3
//#define ruUtf8Nfkd 4
 
#define ruUtf8NoCase 0
 
#define ruUtf8Lower 1
 
#define ruUtf8Upper 2
 
RUAPI char* ruUtf8CaseNormalize(const char *instr, int32_t normMode, int32_t caseMode);
 
RUAPI alloc_chars ruStrFromNfd(trans_chars instr);
 
RUAPI alloc_chars ruStrToNfd(trans_chars instr);
 
RUAPI void ruStrByteReplace(char* string, char search, char replace);
 
RUAPI alloc_chars ruStrReplace(trans_chars instr, trans_chars search,
                               trans_chars replace);
 
RUAPI int32_t ruStrCmp(trans_chars str1, trans_chars str2);
 
RUAPI bool ruStrEquals(trans_chars str1, trans_chars str2);
 
RUAPI bool ruStrNEquals(trans_chars str1, rusize s1len, trans_chars str2);
 
RUAPI int32_t ruStrCaseCmp(trans_chars str1, trans_chars str2);
 
RUAPI bool ruStrCaseEquals(trans_chars str1, trans_chars str2);
 
RUAPI bool ruStrStartsWith(trans_chars str, trans_chars prefix, int32_t *code);
 
RUAPI bool ruStrCaseStartsWith(trans_chars str, trans_chars prefix, int32_t *code);
 
RUAPI bool ruStrEndsWith(trans_chars str, trans_chars suffix, int32_t *code);
 
RUAPI bool ruStrCaseEndsWith(trans_chars str, trans_chars suffix, int32_t *code);
 
RUAPI trans_chars ruStrCaseStrLen(trans_chars haystack, trans_chars needle, rusize len);
 
RUAPI trans_chars ruStrStrLen(trans_chars haystack, trans_chars needle, rusize len);
 
RUAPI trans_chars ruStrStr(trans_chars haystack, trans_chars needle);
 
RUAPI trans_chars ruLastSubStrLen(trans_chars haystack, trans_chars needle, rusize len);
 
RUAPI trans_chars ruLastSubStr(trans_chars haystack, trans_chars needle);
 
RUAPI ruList ruStrNSplit(trans_chars instr, rusize inlen, trans_chars delim, int32_t maxCnt);
 
RUAPI ruList ruStrSplit(trans_chars instr, trans_chars delim, int32_t maxCnt);
 
RUAPI char ruAsciiCharToLower(char in);
 
RUAPI alloc_chars ruAsciiToLower(trans_chars instr);
 
RUAPI alloc_chars ruAsciiNToLower(trans_chars instr, rusize len);
 
RUAPI char ruAsciiCharToUpper(char in);
 
RUAPI alloc_chars ruAsciiToUpper(trans_chars instr);
 
RUAPI alloc_chars ruAsciiNToUpper(trans_chars instr, rusize len);
 
RUAPI alloc_chars ruUtf8ToLower(trans_chars instr);
 
RUAPI alloc_chars ruUtf8ToUpper(trans_chars instr);
 
RUAPI alloc_chars ruStrFromNUtf16(trans_uni unistr, int32_t bytelen);
 
RUAPI alloc_chars ruStrFromUtf16(trans_uni unistr);
 
RUAPI alloc_uni ruStrNToUtf16(trans_chars str, int32_t bytelen);
 
RUAPI alloc_uni ruStrToUtf16(trans_chars str);
 
RUAPI char* ruStrDup(const char* str);
 
RUAPI rusize ruStrLen(trans_chars str);
 
RUAPI char* ruStrNDup(const char* str, rusize len);
 
RUAPI char* ruDupvPrintf(const char* format, va_list arglist);
 
RUAPI char* ruDupPrintf(const char* format, ...);
 
RUAPI bool ruIsInt64(trans_chars str);
 
RUAPI bool ruIsBool(trans_chars str, bool* val);
 
RUAPI int32_t ruStrParseBool(trans_chars str, perm_chars* endptr, bool* out);
 
RUAPI int32_t ruStrParseInt64(trans_chars str, perm_chars* endptr, uint32_t base, int64_t* num);
 
RUAPI int64_t ruStrToInt64(trans_chars str);
 
RUAPI int32_t ruStrParseLong(trans_chars str, perm_chars* endptr, uint32_t base, long* num);
 
RUAPI long ruStrToLong(trans_chars str);
 
RUAPI int32_t ruStrParseInt(trans_chars str, perm_chars* endptr, uint32_t base, int32_t* num);
 
RUAPI int32_t ruStrToInt(trans_chars str);
 
RUAPI bool ruStrHasChar(trans_chars haystack, char needle);
 
RUAPI perm_chars ruStrStrip(perm_chars instr, trans_chars unwanted,
                            alloc_chars* newstr);
 
enum ruTrimSide {
ruTrimBoth = (uint32_t)0,
 
ruTrimStart = 1,
 
ruTrimEnd = 2
 
};
 
RUAPI perm_chars ruStrTrim(perm_chars instr, trans_chars unwanted,
                           enum ruTrimSide ends, alloc_chars* newstr);
 
RUAPI trans_chars ruStrTrimBounds(trans_chars inStart, rusize inLen, rusize* outLen);
 
RUAPI bool ruStrFindKeyVal(trans_chars inStart, rusize inLen, trans_chars delim,
                           trans_chars* keyStart, rusize* keyLen,
                           trans_chars* valStart, rusize* valLen);
 
RUAPI bool ruStrEmpty(trans_chars str);
 
typedef void* ruBuffer;
 
#define ruBufferNew(initialSize) (ruBuffer) ruStringNewn(NULL, initialSize)
 
#define ruBufferAppend(rb, buf, len) ruStringAppendn(rb, buf, len)
 
RUAPI int32_t ruBufferAppendUriEncoded(ruString rs, const char* buf, rusize len);
 
#define ruBufferGetData(rb) ruStringGetCString(rb)
 
#define ruBufferLen(rb, code) ruStringLen(rb, code)
 
#define ruBufferFree(rb, keep) ruStringFree(rb, keep);
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif //REGIFY_UTIL_STRING_H