//////////////////////////////////////////////////////////////////////////////// /// @brief collection of string utility functions /// /// @file /// /// DISCLAIMER /// /// Copyright 2014 ArangoDB GmbH, Cologne, Germany /// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany /// /// Licensed under the Apache License, Version 2.0 (the "License"); /// you may not use this file except in compliance with the License. /// You may obtain a copy of the License at /// /// http://www.apache.org/licenses/LICENSE-2.0 /// /// Unless required by applicable law or agreed to in writing, software /// distributed under the License is distributed on an "AS IS" BASIS, /// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. /// See the License for the specific language governing permissions and /// limitations under the License. /// /// Copyright holder is ArangoDB GmbH, Cologne, Germany /// /// @author Dr. Frank Celler /// @author Dr. Oreste Costa-Panaia /// @author Copyright 2014, ArangoDB GmbH, Cologne, Germany /// @author Copyright 2005-2014, triAGENS GmbH, Cologne, Germany //////////////////////////////////////////////////////////////////////////////// #ifndef ARANGODB_BASICS_STRING_UTILS_H #define ARANGODB_BASICS_STRING_UTILS_H 1 #include "Basics/Common.h" namespace triagens { namespace basics { //////////////////////////////////////////////////////////////////////////////// /// @brief collection of string utility functions /// /// This namespace holds function used for string manipulation. //////////////////////////////////////////////////////////////////////////////// namespace StringUtils { // ----------------------------------------------------------------------------- // STRING AND STRING POINTER // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief creates a blob using new //////////////////////////////////////////////////////////////////////////////// blob_t duplicateBlob (const blob_t&); //////////////////////////////////////////////////////////////////////////////// /// @brief creates a blob using new //////////////////////////////////////////////////////////////////////////////// blob_t duplicateBlob (char const*, size_t); //////////////////////////////////////////////////////////////////////////////// /// @brief creates a blob using new //////////////////////////////////////////////////////////////////////////////// blob_t duplicateBlob (std::string const&); //////////////////////////////////////////////////////////////////////////////// /// @brief creates a C string using new //////////////////////////////////////////////////////////////////////////////// char* duplicate (std::string const&); //////////////////////////////////////////////////////////////////////////////// /// @brief creates a C string using new //////////////////////////////////////////////////////////////////////////////// char* duplicate (char const*, size_t); //////////////////////////////////////////////////////////////////////////////// /// @brief creates a C string using new //////////////////////////////////////////////////////////////////////////////// char* duplicate (char const*); //////////////////////////////////////////////////////////////////////////////// /// @brief deletes and clears a string /// /// The string is cleared using memset and then deleted. The pointer is /// set to 0. //////////////////////////////////////////////////////////////////////////////// void destroy (char*&); //////////////////////////////////////////////////////////////////////////////// /// @brief deletes and clears a string /// /// The string is cleared using memset and then deleted. The pointer is /// set to 0. //////////////////////////////////////////////////////////////////////////////// void destroy (char*&, size_t); //////////////////////////////////////////////////////////////////////////////// /// @brief deletes and clears a string /// /// The string is cleared using memset and then deleted. The pointer is /// set to 0. //////////////////////////////////////////////////////////////////////////////// void destroy (blob_t&); //////////////////////////////////////////////////////////////////////////////// /// @brief deletes but does not clear a character string /// /// The pointer deleted and then set to 0. //////////////////////////////////////////////////////////////////////////////// void erase (char*&); //////////////////////////////////////////////////////////////////////////////// /// @brief deletes but does not clear a blob /// /// The data pointer deleted and then set to 0, and the length is set to 0. //////////////////////////////////////////////////////////////////////////////// void erase (blob_t&); // ----------------------------------------------------------------------------- // STRING CONVERSION // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief capitalize string /// /// This method converts characters at the beginning of a word to uppercase /// and remove any whitespaces. If first is true the first character of the /// first word is also converted to uppercase. Name must not be empty. //////////////////////////////////////////////////////////////////////////////// std::string capitalize (std::string const& name, bool first = true); //////////////////////////////////////////////////////////////////////////////// /// @brief separate words /// /// This method converts all characters to lowercase and separates /// the words with a given character. Name must not be empty. //////////////////////////////////////////////////////////////////////////////// std::string separate (std::string const& name, char separator = '-'); //////////////////////////////////////////////////////////////////////////////// /// @brief escape delimiter /// /// This method escapes a set of character with a given escape character. The /// escape character is also escaped. //////////////////////////////////////////////////////////////////////////////// std::string escape (std::string const& name, std::string const& specials, char quote = '\\'); //////////////////////////////////////////////////////////////////////////////// /// @brief escape delimiter /// /// This method escapes a set of character with a given escape character. The /// escape character is also escaped. //////////////////////////////////////////////////////////////////////////////// std::string escape (std::string const& name, size_t len, std::string const& specials, char quote = '\\'); //////////////////////////////////////////////////////////////////////////////// /// @brief escape unicode /// /// This method escapes a unicode character string by replacing the unicode /// characters by a \\uXXXX sequence. //////////////////////////////////////////////////////////////////////////////// std::string escapeUnicode (std::string const& name, bool escapeSlash = true); //////////////////////////////////////////////////////////////////////////////// /// @brief escape html //////////////////////////////////////////////////////////////////////////////// std::string escapeHtml (std::string const& name); //////////////////////////////////////////////////////////////////////////////// /// @brief escape xml //////////////////////////////////////////////////////////////////////////////// std::string escapeXml (std::string const& name); //////////////////////////////////////////////////////////////////////////////// /// @brief escape hex for all non-printable characters (including space) //////////////////////////////////////////////////////////////////////////////// std::string escapeHex (std::string const& name, char quote = '%'); //////////////////////////////////////////////////////////////////////////////// /// @brief escape hex //////////////////////////////////////////////////////////////////////////////// std::string escapeHex (std::string const& name, std::string const& specials, char quote = '%'); //////////////////////////////////////////////////////////////////////////////// /// @brief escape as C code //////////////////////////////////////////////////////////////////////////////// std::string escapeC (std::string const& name); //////////////////////////////////////////////////////////////////////////////// /// @brief splits a string //////////////////////////////////////////////////////////////////////////////// std::vector split (std::string const& source, char delim = ',', char quote = '\\'); //////////////////////////////////////////////////////////////////////////////// /// @brief splits a string //////////////////////////////////////////////////////////////////////////////// std::vector split (std::string const& source, std::string const& delim, char quote = '\\'); //////////////////////////////////////////////////////////////////////////////// /// @brief joins a string //////////////////////////////////////////////////////////////////////////////// std::string join (std::vector const& source, char delim = ','); //////////////////////////////////////////////////////////////////////////////// /// @brief joins a string //////////////////////////////////////////////////////////////////////////////// std::string join (std::vector const& source, std::string const& delim = ","); //////////////////////////////////////////////////////////////////////////////// /// @brief joins a string //////////////////////////////////////////////////////////////////////////////// std::string join (std::set const& source, char delim = ','); //////////////////////////////////////////////////////////////////////////////// /// @brief joins a string //////////////////////////////////////////////////////////////////////////////// std::string join (std::set const& source, std::string const& delim = ","); //////////////////////////////////////////////////////////////////////////////// /// @brief removes leading and trailing whitespace //////////////////////////////////////////////////////////////////////////////// std::string trim (std::string const& sourceStr, std::string const& trimStr = " \t\n\r"); //////////////////////////////////////////////////////////////////////////////// /// @brief removes leading and trailing whitespace in place //////////////////////////////////////////////////////////////////////////////// void trimInPlace (std::string& str, std::string const& trimStr = " \t\n\r"); //////////////////////////////////////////////////////////////////////////////// /// @brief removes leading whitespace //////////////////////////////////////////////////////////////////////////////// std::string lTrim(std::string const& sourceStr, std::string const& trimStr = " \t\n\r"); //////////////////////////////////////////////////////////////////////////////// /// @brief removes trailing whitespace //////////////////////////////////////////////////////////////////////////////// std::string rTrim(std::string const& sourceStr, std::string const& trimStr = " \t\n\r"); //////////////////////////////////////////////////////////////////////////////// /// @brief fills string from left //////////////////////////////////////////////////////////////////////////////// std::string lFill(std::string const& sourceStr, size_t size, char fill = ' '); //////////////////////////////////////////////////////////////////////////////// /// @brief fills string from right //////////////////////////////////////////////////////////////////////////////// std::string rFill(std::string const& sourceStr, size_t size, char fill = ' '); //////////////////////////////////////////////////////////////////////////////// /// @brief wrap longs lines //////////////////////////////////////////////////////////////////////////////// std::vector wrap(std::string const& sourceStr, size_t size, std::string breaks = " "); //////////////////////////////////////////////////////////////////////////////// /// @brief substring replace //////////////////////////////////////////////////////////////////////////////// std::string replace (std::string const& sourceStr, std::string const& fromString, std::string const& toString); //////////////////////////////////////////////////////////////////////////////// /// @brief converts string to lower case in place //////////////////////////////////////////////////////////////////////////////// void tolowerInPlace (std::string* str); //////////////////////////////////////////////////////////////////////////////// /// @brief converts string to lower case //////////////////////////////////////////////////////////////////////////////// std::string tolower (std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief converts string to upper case in place //////////////////////////////////////////////////////////////////////////////// void toupperInPlace (std::string* str); //////////////////////////////////////////////////////////////////////////////// /// @brief converts string to upper case //////////////////////////////////////////////////////////////////////////////// std::string toupper (std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief checks for a prefix //////////////////////////////////////////////////////////////////////////////// bool isPrefix (std::string const& str, std::string const& prefix); //////////////////////////////////////////////////////////////////////////////// /// @brief checks for a suffix //////////////////////////////////////////////////////////////////////////////// bool isSuffix (std::string const& str, std::string const& postfix); //////////////////////////////////////////////////////////////////////////////// /// @brief url decodes the string //////////////////////////////////////////////////////////////////////////////// std::string urlDecode (std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief url encodes the string //////////////////////////////////////////////////////////////////////////////// std::string urlEncode (const char* src); //////////////////////////////////////////////////////////////////////////////// /// @brief url encodes the string //////////////////////////////////////////////////////////////////////////////// std::string urlEncode (const char* src, const size_t len); //////////////////////////////////////////////////////////////////////////////// /// @brief unicode hexidecmial characters to utf8 //////////////////////////////////////////////////////////////////////////////// bool unicodeToUTF8 (const char* inputStr, const size_t& len, std::string& outputStr); //////////////////////////////////////////////////////////////////////////////// /// @brief converts an utf16 symbol which needs UTF16 to UTF8 /// The conversion correspond to the specification: /// http://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B10000_to_U.2B10FFFF //////////////////////////////////////////////////////////////////////////////// bool convertUTF16ToUTF8 (const char* high_surrogate, const char* low_surrogate, std::string& outputStr); //////////////////////////////////////////////////////////////////////////////// /// @brief url encodes the string //////////////////////////////////////////////////////////////////////////////// std::string urlEncode (std::string const& str); // ----------------------------------------------------------------------------- // CONVERT TO STRING // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief converts integer to string //////////////////////////////////////////////////////////////////////////////// std::string itoa (int16_t i); //////////////////////////////////////////////////////////////////////////////// /// @brief converts unsigned integer to string //////////////////////////////////////////////////////////////////////////////// std::string itoa (uint16_t i); //////////////////////////////////////////////////////////////////////////////// /// @brief converts integer to string //////////////////////////////////////////////////////////////////////////////// std::string itoa (int64_t i); //////////////////////////////////////////////////////////////////////////////// /// @brief converts unsigned integer to string //////////////////////////////////////////////////////////////////////////////// std::string itoa (uint64_t i); //////////////////////////////////////////////////////////////////////////////// /// @brief converts integer to string //////////////////////////////////////////////////////////////////////////////// std::string itoa (int32_t i); //////////////////////////////////////////////////////////////////////////////// /// @brief converts unsigned integer to string //////////////////////////////////////////////////////////////////////////////// std::string itoa (uint32_t i); //////////////////////////////////////////////////////////////////////////////// /// @brief converts size_t to string //////////////////////////////////////////////////////////////////////////////// #ifdef TRI_OVERLOAD_FUNCS_SIZE_T #if TRI_SIZEOF_SIZE_T == 4 inline std::string itoa (size_t i) { return itoa(uint32_t(i)); } #elif TRI_SIZEOF_SIZE_T == 8 inline std::string itoa (size_t i) { return itoa(uint64_t(i)); } #endif #endif //////////////////////////////////////////////////////////////////////////////// /// @brief converts decimal to string //////////////////////////////////////////////////////////////////////////////// std::string ftoa (double i); // ----------------------------------------------------------------------------- // CONVERT FROM STRING // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief converts a single hex to integer //////////////////////////////////////////////////////////////////////////////// inline int hex2int (char ch, int errorValue = 0) { if ('0' <= ch && ch <= '9') { return ch - '0'; } else if ('A' <= ch && ch <= 'F') { return ch - 'A' + 10; } else if ('a' <= ch && ch <= 'f') { return ch - 'a' + 10; } return errorValue; } //////////////////////////////////////////////////////////////////////////////// /// @brief parses a boolean //////////////////////////////////////////////////////////////////////////////// bool boolean (std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief parses an integer //////////////////////////////////////////////////////////////////////////////// int64_t int64 (std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief parses an integer //////////////////////////////////////////////////////////////////////////////// int64_t int64 (char const* value, size_t size); //////////////////////////////////////////////////////////////////////////////// /// @brief parses an unsigned integer //////////////////////////////////////////////////////////////////////////////// uint64_t uint64 (std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief parses an unsigned integer //////////////////////////////////////////////////////////////////////////////// uint64_t uint64 (char const* value, size_t size); //////////////////////////////////////////////////////////////////////////////// /// @brief parses an integer //////////////////////////////////////////////////////////////////////////////// int32_t int32 (std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief parses an integer //////////////////////////////////////////////////////////////////////////////// int32_t int32 (char const* value, size_t size); //////////////////////////////////////////////////////////////////////////////// /// @brief parses an unsigned integer //////////////////////////////////////////////////////////////////////////////// uint32_t uint32 (std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief parses an unsigned integer //////////////////////////////////////////////////////////////////////////////// uint32_t uint32 (char const* value, size_t size); //////////////////////////////////////////////////////////////////////////////// /// @brief parses an unsigned integer given in HEX //////////////////////////////////////////////////////////////////////////////// uint32_t unhexUint32 (std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief parses an unsigned integer given in HEX //////////////////////////////////////////////////////////////////////////////// uint32_t unhexUint32 (char const* value, size_t size); //////////////////////////////////////////////////////////////////////////////// /// @brief parses a decimal //////////////////////////////////////////////////////////////////////////////// double doubleDecimal (std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief parses a decimal //////////////////////////////////////////////////////////////////////////////// double doubleDecimal (char const* value, size_t size); //////////////////////////////////////////////////////////////////////////////// /// @brief parses a decimal //////////////////////////////////////////////////////////////////////////////// float floatDecimal (std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief parses a decimal //////////////////////////////////////////////////////////////////////////////// float floatDecimal (char const* value, size_t size); //////////////////////////////////////////////////////////////////////////////// /// @brief parses a time //////////////////////////////////////////////////////////////////////////////// seconds_t seconds (std::string const& format, std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief formats a time using the extended ISO 8601 format //////////////////////////////////////////////////////////////////////////////// std::string formatSeconds (seconds_t); //////////////////////////////////////////////////////////////////////////////// /// @brief formats a time using the oracle format string //////////////////////////////////////////////////////////////////////////////// std::string formatSeconds (std::string const& format, seconds_t); //////////////////////////////////////////////////////////////////////////////// /// @brief parses a date //////////////////////////////////////////////////////////////////////////////// date_t date (std::string const& format, std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief formats a date using the extended ISO 8601 format //////////////////////////////////////////////////////////////////////////////// std::string formatDate (date_t); //////////////////////////////////////////////////////////////////////////////// /// @brief formats a date using the oracle format string //////////////////////////////////////////////////////////////////////////////// std::string formatDate (std::string const& format, date_t); //////////////////////////////////////////////////////////////////////////////// /// @brief parses a date and time //////////////////////////////////////////////////////////////////////////////// datetime_t datetime (std::string const& format, std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief formats a datetime using the extended ISO 8601 format //////////////////////////////////////////////////////////////////////////////// std::string formatDatetime (datetime_t); //////////////////////////////////////////////////////////////////////////////// /// @brief formats a datetime using the oracle format string //////////////////////////////////////////////////////////////////////////////// std::string formatDatetime (std::string const& format, datetime_t); //////////////////////////////////////////////////////////////////////////////// /// @brief formats a date and time using the extended ISO 8601 format //////////////////////////////////////////////////////////////////////////////// std::string formatDateTime (date_t, seconds_t); //////////////////////////////////////////////////////////////////////////////// /// @brief formats a date and time using the oracle format string //////////////////////////////////////////////////////////////////////////////// std::string formatDateTime (std::string const& format, date_t, seconds_t); // ----------------------------------------------------------------------------- // BASE64 // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief converts to base64 //////////////////////////////////////////////////////////////////////////////// std::string encodeBase64 (std::string const&); //////////////////////////////////////////////////////////////////////////////// /// @brief converts from base64 //////////////////////////////////////////////////////////////////////////////// std::string decodeBase64 (std::string const&); //////////////////////////////////////////////////////////////////////////////// /// @brief converts to base64, URL friendly /// /// '-' and '_' are used instead of '+' and '/' //////////////////////////////////////////////////////////////////////////////// std::string encodeBase64U (std::string const&); //////////////////////////////////////////////////////////////////////////////// /// @brief converts from base64, URL friendly /// /// '-' and '_' are used instead of '+' and '/' //////////////////////////////////////////////////////////////////////////////// std::string decodeBase64U (std::string const&); // ----------------------------------------------------------------------------- // ADDITIONAL STRING UTILITIES // ----------------------------------------------------------------------------- //////////////////////////////////////////////////////////////////////////////// /// @brief replaces incorrect path delimiter character for window and linux //////////////////////////////////////////////////////////////////////////////// std::string correctPath (const std::string& incorrectPath); //////////////////////////////////////////////////////////////////////////////// /// @brief finds n.th entry //////////////////////////////////////////////////////////////////////////////// std::string entry (const size_t pos, std::string const& sourceStr, std::string const& delimiter = ","); //////////////////////////////////////////////////////////////////////////////// /// @brief counts number of entires //////////////////////////////////////////////////////////////////////////////// size_t numEntries(std::string const& sourceStr, std::string const& delimiter = ","); //////////////////////////////////////////////////////////////////////////////// /// @brief converts to hex //////////////////////////////////////////////////////////////////////////////// std::string encodeHex (std::string const& str); //////////////////////////////////////////////////////////////////////////////// /// @brief converts from hex //////////////////////////////////////////////////////////////////////////////// std::string decodeHex (std::string const& str); } } } #endif // ----------------------------------------------------------------------------- // --SECTION-- END-OF-FILE // ----------------------------------------------------------------------------- // Local Variables: // mode: outline-minor // outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @page\\|// --SECTION--\\|/// @\\}" // End: