wcharstring.h

// Copyright (c) 1999-2018 David Muse
// See the COPYING file for more information.
 
#ifndef RUDIMENTS_WCHARSTRING_H
#define RUDIMENTS_WCHARSTRING_H
 
#include <rudiments/private/wcharstringincludes.h>
 
class RUDIMENTS_DLLSPEC wcharstring {
        public:
 
                static  size_t  getLength(const wchar_t *string);
 
                static  size_t  getSize(const wchar_t *string);
 
                static  bool    isNullOrEmpty(const wchar_t *string);
 
                static  bool    isYes(const wchar_t *string);
 
                static  bool    isNo(const wchar_t *string);
 
                static  void    zero(wchar_t *str, size_t len);
 
                static  wchar_t *append(wchar_t *dest, const wchar_t *source);
 
                static  wchar_t *append(wchar_t *dest, const wchar_t *source,
                                                                size_t len);
 
                static  wchar_t *append(wchar_t *dest, int64_t number);
 
                static  wchar_t *append(wchar_t *dest, uint64_t number);
 
                static  wchar_t *append(wchar_t *dest, double number);
 
                static  wchar_t *append(wchar_t *dest, double number,
                                                        uint16_t scale);
 
                static  wchar_t *append(wchar_t *dest, double number,
                                                uint16_t precision,
                                                uint16_t scale);
 
                static  wchar_t *copy(wchar_t *dest, const wchar_t *source);
 
                static  wchar_t *copy(wchar_t *dest,
                                        const wchar_t *source, size_t len);
 
                static  wchar_t *copy(wchar_t *dest, size_t location,
                                                const wchar_t *source);
 
                static  wchar_t *copy(wchar_t *dest, size_t location,
                                        const wchar_t *source, size_t len);
 
                static wchar_t  *safeCopy(wchar_t *dest, size_t destlen,
                                                        const wchar_t *source);
 
                static wchar_t  *safeCopy(wchar_t *dest,
                                                size_t destlen,
                                                const wchar_t *source,
                                                size_t sourcelen);
 
                static  int32_t compare(const wchar_t *str1,
                                                const wchar_t *str2);
 
                static  int32_t compare(const wchar_t *str1,
                                                const wchar_t *str2,
                                                size_t len);
 
                static  int32_t compareIgnoringCase(const wchar_t *str1,
                                                        const wchar_t *str2);
 
                static  int32_t compareIgnoringCase(const wchar_t *str1,
                                                        const wchar_t *str2,
                                                        size_t len);
 
                static  int32_t compareNatural(const wchar_t *str1,
                                                const wchar_t *str2);
 
                static  int32_t compareNatural(const wchar_t *str1,
                                                const wchar_t *str2,
                                                const wchar_t *delimiters);
 
                static  int32_t compareVersions(const wchar_t *str1,
                                                const wchar_t *str2);
 
                static  int32_t compareVersions(const wchar_t *str1,
                                                const wchar_t *str2,
                                                const wchar_t *delimiters);
 
                static  bool    compareWithWildcards(const wchar_t *string,
                                                        size_t stringlength,
                                                        const wchar_t *pattern,
                                                        size_t patternlength,
                                                        wchar_t singlewildcard,
                                                        wchar_t multiwildcard);
 
                static  bool    compareWithWildcards(const wchar_t *string,
                                                        const wchar_t *pattern,
                                                        size_t patternlength,
                                                        wchar_t singlewildcard,
                                                        wchar_t multiwildcard);
 
                static  bool    compareWithWildcards(const wchar_t *string,
                                                        size_t stringlength,
                                                        const wchar_t *pattern,
                                                        wchar_t singlewildcard,
                                                        wchar_t multiwildcard);
 
                static  bool    compareWithWildcards(const wchar_t *string,
                                                        const wchar_t *pattern,
                                                        wchar_t singlewildcard,
                                                        wchar_t multiwildcard);
 
                static  bool    isInSet(const wchar_t *str,
                                        const wchar_t * const *set);
 
                static  bool    isInSetIgnoringCase(const wchar_t *str,
                                                const wchar_t * const *set);
 
                static  bool    contains(const wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  bool    containsIgnoringCase(const wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  bool    contains(const wchar_t *haystack,
                                                        wchar_t needle);
 
                static  bool    containsIgnoringCase(const wchar_t *haystack,
                                                                wchar_t needle);
 
                static  bool    startsWith(const wchar_t *haystack,
                                                const wchar_t *needle);
 
                static  bool    endsWith(const wchar_t *haystack,
                                                const wchar_t *needle);
 
                static  const wchar_t   *findFirst(const wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  const wchar_t   *findFirstIgnoringCase(
                                                        const wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  const wchar_t   *findFirst(const wchar_t *haystack,
                                                        wchar_t needle);
 
                static  const wchar_t   *findFirstIgnoringCase(
                                                        const wchar_t *haystack,
                                                        wchar_t needle);
 
                static  const wchar_t   *findFirstOrEnd(const wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  const wchar_t   *findFirstOrEndIgnoringCase(
                                                        const wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  const wchar_t   *findFirstOrEnd(const wchar_t *haystack,
                                                        wchar_t needle);
 
                static  const wchar_t   *findFirstOrEndIgnoringCase(
                                                        const wchar_t *haystack,
                                                        wchar_t needle);
 
                static  const wchar_t   *findLast(const wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  const wchar_t   *findLast(const wchar_t *haystack,
                                                        wchar_t needle);
 
                static  wchar_t *findFirst(wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  wchar_t *findFirstIgnoringCase(wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  wchar_t *findFirst(wchar_t *haystack, wchar_t needle);
 
                static  wchar_t *findFirstIgnoringCase(wchar_t *haystack,
                                                                wchar_t needle);
 
                static  wchar_t *findFirstOrEnd(wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  wchar_t *findFirstOrEndIgnoringCase(wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  wchar_t *findLast(wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  const wchar_t   *findLastIgnoringCase(
                                                        const wchar_t *haystack,
                                                        const wchar_t *needle);
 
                static  wchar_t *findLast(wchar_t *haystack, wchar_t needle);
 
                static  const wchar_t   *findLastIgnoringCase(
                                                        const wchar_t *haystack,
                                                        wchar_t needle);
 
                static const wchar_t    *findFirstOfSet(const wchar_t *haystack,
                                                        const wchar_t *set);
 
                static wchar_t          *findFirstOfSet(wchar_t *haystack,
                                                        const wchar_t *set);
 
                static const wchar_t    *findFirstOfSetOrEnd(
                                                        const wchar_t *haystack,
                                                        const wchar_t *set);
 
                static wchar_t          *findFirstOfSetOrEnd(
                                                        wchar_t *haystack,
                                                        const wchar_t *set);
 
                static const wchar_t    *findLastOfSet(const wchar_t *haystack,
                                                        const wchar_t *set);
 
                static wchar_t          *findLastOfSet(wchar_t *haystack,
                                                        const wchar_t *set);
 
                static const wchar_t    *findLastOfSetOrEnd(
                                                        const wchar_t *haystack,
                                                        const wchar_t *set);
 
                static wchar_t          *findLastOfSetOrEnd(
                                                        wchar_t *haystack,
                                                        const wchar_t *set);
 
                static wchar_t  *findEndOfQuotedString(wchar_t *string,
                                                        wchar_t quote,
                                                        bool backslash,
                                                        bool doubling);
 
                static const wchar_t    *findEndOfQuotedString(
                                                        const wchar_t *string,
                                                        wchar_t quote,
                                                        bool backslash,
                                                        bool doubling);
 
                static wchar_t  *findEndOfQuotedString(wchar_t *string,
                                                        size_t stringlen,
                                                        wchar_t quote,
                                                        bool backslash,
                                                        bool doubling);
 
                static const wchar_t    *findEndOfQuotedString(
                                                        const wchar_t *string,
                                                        size_t stringlen,
                                                        wchar_t quote,
                                                        bool backslash,
                                                        bool doubling);
 
                static wchar_t  *findEndOfQuotedString(wchar_t *string,
                                                        bool backslash,
                                                        bool doubling);
 
                static const wchar_t    *findEndOfQuotedString(
                                                        const wchar_t *string,
                                                        bool backslash,
                                                        bool doubling);
 
                static wchar_t  *findEndOfQuotedString(wchar_t *string,
                                                        size_t stringlen,
                                                        bool backslash,
                                                        bool doubling);
 
                static const wchar_t    *findEndOfQuotedString(
                                                        const wchar_t *string,
                                                        size_t stringlen,
                                                        bool backslash,
                                                        bool doubling);
 
                static wchar_t  *isBefore(const wchar_t *str,
                                                const wchar_t *delimiter);
 
                static wchar_t  *isBetween(const wchar_t *str,
                                                const wchar_t *start,
                                                const wchar_t *end);
 
                static wchar_t  *isAfter(const wchar_t *str,
                                                const wchar_t *delimiter);
 
                static size_t   getLengthContainingSet(
                                                const wchar_t *haystack,
                                                const wchar_t *set);
 
                static size_t   getLengthNotContainingSet(
                                                const wchar_t *haystack,
                                                const wchar_t *set);
 
                static  wchar_t *duplicate(const wchar_t *str);
 
                static  wchar_t *duplicate(const wchar_t *str, size_t len);
 
                static  wchar_t *duplicate(const char *str);
 
                static  wchar_t *duplicate(const char *str, size_t len);
 
                static  wchar_t *duplicateUcs2(const ucs2_t *str);
 
                static  wchar_t *duplicateUcs2(const ucs2_t *str, size_t len);
 
                static  wchar_t *duplicateUcs2(const ucs2_t *str,
                                                        bool bigendian);
 
                static  wchar_t *duplicateUcs2(const ucs2_t *str,
                                                        size_t len,
                                                        bool bigendian);
 
                static  wchar_t *duplicateUcs2(const ucs2_t *str,
                                                        wchar_t replacement);
 
                static  wchar_t *duplicateUcs2(const ucs2_t *str,
                                                        size_t len,
                                                        wchar_t replacement);
 
                static  wchar_t *duplicateUcs2(const ucs2_t *str,
                                                        wchar_t replacement,
                                                        bool bigendian);
 
                static  wchar_t *duplicateUcs2(const ucs2_t *str,
                                                        size_t len,
                                                        wchar_t replacement,
                                                        bool bigendian);
 
                static  void    upper(wchar_t *str); 
 
                static  void    lower(wchar_t *str); 
 
                static void     capitalize(wchar_t *str);
 
                static  void    rightTrim(wchar_t *str);
 
                static  void    rightTrim(wchar_t *str, wchar_t character);
 
                static  void    leftTrim(wchar_t *str);
 
                static  void    leftTrim(wchar_t *str, wchar_t character);
 
                static  void    bothTrim(wchar_t *str);
 
                static  void    bothTrim(wchar_t *str, wchar_t character);
 
                static  bool    strip(wchar_t *str, wchar_t character);
 
                static  bool    strip(wchar_t *str1, const wchar_t *str2);
 
                static  bool    stripSet(wchar_t *str1, const wchar_t *set);
 
                static  void    replace(wchar_t *str,
                                        wchar_t oldchar,
                                        wchar_t newchar);
 
                static  void    replace(wchar_t *str,
                                        const wchar_t *oldchars,
                                        wchar_t newchar);
 
                static  wchar_t *replace(const wchar_t *str,
                                                const wchar_t *oldstr,
                                                const wchar_t *newstr);
 
                static  wchar_t *replace(const wchar_t *str,
                                        const wchar_t * const *oldstrset,
                                        size_t *oldstrlen,
                                        const wchar_t * const *newstrset);
 
                static  void    replaceIgnoringCase(wchar_t *str,
                                        wchar_t oldchar,
                                        wchar_t newchar);
 
                static  void    replaceIgnoringCase(wchar_t *str,
                                        const wchar_t *oldchars,
                                        wchar_t newchar);
 
                static  wchar_t *replaceIgnoringCase(const wchar_t *str,
                                                const wchar_t *oldstr,
                                                const wchar_t *newstr);
 
                static  wchar_t *replaceIgnoringCase(const wchar_t *str,
                                        const wchar_t * const *oldstrset,
                                        size_t *oldstrlen,
                                        const wchar_t * const *newstrset);
 
                static  uint16_t        getIntegerLength(int16_t number);
 
                static  uint16_t        getIntegerLength(int32_t number);
 
                static  uint16_t        getIntegerLength(int64_t number);
 
                static  uint16_t        getIntegerLength(uint16_t number);
 
                static  uint16_t        getIntegerLength(uint32_t number);
 
                static  uint16_t        getIntegerLength(uint64_t number);
 
                static  bool    isInteger(const wchar_t *val);
 
                static  bool    isInteger(const wchar_t *val, int32_t len);
 
                static  bool    isNumber(const wchar_t *val);
 
                static  bool    isNumber(const wchar_t *val, int32_t len);
 
                static  wchar_t *parseNumber(int16_t number);
 
                static  wchar_t *parseNumber(uint16_t number);
 
                static  wchar_t *parseNumber(int16_t number,
                                                uint16_t zeropadding);
 
                static  wchar_t *parseNumber(uint16_t number,
                                                uint16_t zeropadding);
 
                static  wchar_t *parseNumber(int32_t number);
 
                static  wchar_t *parseNumber(uint32_t number);
 
                static  wchar_t *parseNumber(int32_t number,
                                                uint16_t zeropadding);
 
                static  wchar_t *parseNumber(uint32_t number,
                                                uint16_t zeropadding);
 
                static  wchar_t *parseNumber(int64_t number);
 
                static  wchar_t *parseNumber(uint64_t number);
 
                static  wchar_t *parseNumber(int64_t number,
                                                uint16_t zeropadding);
 
                static  wchar_t *parseNumber(uint64_t number,
                                                uint16_t zeropadding);
 
 
                static  wchar_t *parseNumber(float number);
 
                static  wchar_t *parseNumber(float number,
                                                uint16_t scale);
 
                static  wchar_t *parseNumber(float number,
                                                uint16_t precision,
                                                uint16_t scale);
 
                static  wchar_t *parseNumber(double number);
 
                static  wchar_t *parseNumber(double number,
                                                uint16_t scale);
 
                static  wchar_t *parseNumber(double number,
                                                uint16_t precision,
                                                uint16_t scale);
 
                static  wchar_t *parseNumber(long double number);
 
                static  wchar_t *parseNumber(long double number,
                                                uint16_t scale);
 
                static  wchar_t *parseNumber(long double number,
                                                uint16_t precision,
                                                uint16_t scale);
 
                static  int64_t convertToInteger(const wchar_t *string);
 
                static  int64_t convertToInteger(const wchar_t *string,
                                                const wchar_t **endptr);
 
                static  int64_t convertToInteger(const wchar_t *string,
                                                int32_t base);
 
                static  int64_t convertToInteger(const wchar_t *string,
                                                const wchar_t **endptr,
                                                int32_t base);
 
                static  uint64_t        convertToUnsignedInteger(
                                                const wchar_t *string);
 
                static  uint64_t        convertToUnsignedInteger(
                                                const wchar_t *string,
                                                const wchar_t **endptr);
 
                static  uint64_t        convertToUnsignedInteger(
                                                const wchar_t *string,
                                                int32_t base);
 
                static  uint64_t        convertToUnsignedInteger(
                                                const wchar_t *string,
                                                const wchar_t **endptr,
                                                int32_t base);
 
 
                static  long double     convertToFloat(const wchar_t *string);
 
                static  long double     convertToFloatC(const wchar_t *string);
 
                static  long double     convertToFloat(const wchar_t *string,
                                                        const wchar_t **endptr);
 
                static  int64_t convertAmount(const wchar_t *amount);
 
                static  wchar_t *convertAmount(int64_t amount);
 
                static  wchar_t *convertAmount(int64_t amount,
                                                uint16_t padding);
 
 
                static  wchar_t *escape(const wchar_t *input,
                                        const wchar_t *characters);
 
                static  wchar_t *unescape(const wchar_t *input);
 
                static  void    escape(const wchar_t *input, uint64_t inputlen,
                                        wchar_t **output, uint64_t *outputlen,
                                        const wchar_t *characters);
 
                static  void    unescape(const wchar_t *input,
                                                uint64_t inputlen,
                                                wchar_t **output,
                                                uint64_t *outputlen);
 
                static  void    leftJustify(wchar_t *str, int32_t len);
 
                static  void    rightJustify(wchar_t *str, int32_t len);
 
                static  void    center(wchar_t *str, int32_t len);
 
                static wchar_t  *pad(const wchar_t *string,
                                                wchar_t padchar,
                                                int16_t direction,
                                                uint64_t totallength);
 
                static void     split(const wchar_t *string,
                                        size_t stringlength,
                                        const wchar_t *delimiter,
                                        size_t delimiterlength,
                                        bool collapse,
                                        wchar_t ***list,
                                        uint64_t *listcount);
 
                static void     split(const wchar_t *string,
                                        const wchar_t *delimiter,
                                        size_t delimiterlength,
                                        bool collapse,
                                        wchar_t ***list,
                                        uint64_t *listcount);
 
                static void     split(const wchar_t *string,
                                        size_t stringlength,
                                        const wchar_t *delimiter,
                                        bool collapse,
                                        wchar_t ***list,
                                        uint64_t *listcount);
 
                static void     split(const wchar_t *string,
                                        const wchar_t *delimiter,
                                        bool collapse,
                                        wchar_t ***list,
                                        uint64_t *listcount);
 
                static wchar_t  *getSubString(const wchar_t *str,
                                                size_t start, size_t end);
 
                static wchar_t  *getSubString(const wchar_t *str, size_t start);
 
                static wchar_t  *insertString(const wchar_t *dest,
                                                const wchar_t *src,
                                                uint64_t index);
 
                static wchar_t  *getHumanReadable(int64_t number);
 
                static wchar_t  *getHumanReadable(int64_t number,
                                                        bool onethousand);
 
                static wchar_t  *getHumanReadable(uint64_t number);
 
                static wchar_t  *getHumanReadable(uint64_t number,
                                                        bool onethousand);
 
                static wchar_t  *getHumanReadable(long double number);
 
                static wchar_t  *getHumanReadable(long double number,
                                                        bool onethousand);
 
                static ssize_t  printf(wchar_t *buffer, size_t len,
                                                const wchar_t *format, ...);
 
                static ssize_t  printf(wchar_t *buffer, size_t len,
                                                const wchar_t *format,
                                                va_list *argp);
 
                static ssize_t  printf(wchar_t **buffer,
                                                const wchar_t *format, ...);
 
                static ssize_t  printf(wchar_t **buffer,
                                                const wchar_t *format,
                                                va_list *argp);
 
                static bool     supportsPrintf();
 
        #include <rudiments/private/wcharstring.h>
};
 
#endif