Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
arangodb/lib/Basics/StringUtils.cpp

3353 lines
92 KiB
C++
Raw Blame History

////////////////////////////////////////////////////////////////////////////////
/// @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 Copyright 2014, ArangoDB GmbH, Cologne, Germany
/// @author Copyright 2005-2013, triAGENS GmbH, Cologne, Germany
////////////////////////////////////////////////////////////////////////////////
#include "StringUtils.h"
#include <math.h>
#include <time.h>
#include <iostream>
#include "Basics/logging.h"
#include "Basics/tri-strings.h"
#include "Basics/Exceptions.h"
#include "Basics/StringBuffer.h"
// TODO need to this in another way
#ifndef TRI_HAVE_GLOBAL_TIMEZONE_PROTO
#ifdef GLOBAL_TIMEZONE
extern long GLOBAL_TIMEZONE;
#else
static long GLOBAL_TIMEZONE = 0;
#endif
#endif
using namespace std;
// -----------------------------------------------------------------------------
// helper functions
// -----------------------------------------------------------------------------
namespace {
bool isSpace (char a) {
return a == ' ' || a == '\t' || a == '_';
}
int32_t matchInteger (char const * & str, size_t size) {
int32_t result = 0;
for (size_t i = 0; i < size; i++, str++) {
if ('0' <= *str && *str <= '9') {
result = result * 10 + (*str - '0');
}
else {
std::string message("cannot parse date, expecting integer, got '" + string(1, *str) + "'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
return result;
}
int32_t matchInteger (char const * & str) {
int32_t result = 0;
for (; *str; str++) {
if ('0' <= *str && *str <= '9') {
result = result * 10 + (*str - '0');
}
else {
return result;
}
}
return result;
}
char const * const BASE64_CHARS =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
char const * const BASE64U_CHARS =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789-_";
unsigned char const BASE64_REVS[256] = {
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 0
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 16
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', 62, '\0', '\0', '\0', 63, // 32 ' ', '!'
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, '\0', '\0', '\0', '\0', '\0', '\0', // 48 '0', '1'
'\0', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, // 64 '@', 'A'
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, '\0', '\0', '\0', '\0', '\0', // 80
'\0', 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, // 96 '`', 'a'
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, '\0', '\0', '\0', '\0', '\0', // 112
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 128
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 144
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 160
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 176
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 192
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 208
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 224
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 240
};
unsigned char const BASE64U_REVS[256] = {
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 0
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 16
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', 62, '\0', '\0', // 32 ' ', '!'
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, '\0', '\0', '\0', '\0', '\0', '\0', // 48 '0', '1'
'\0', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, // 64 '@', 'A'
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, '\0', '\0', '\0', '\0', 63, // 80
'\0', 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, // 96 '`', 'a'
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, '\0', '\0', '\0', '\0', '\0', // 112
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 128
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 144
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 160
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 176
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 192
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 208
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 224
'\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', '\0', // 240
};
inline bool isBase64 (unsigned char c) {
return (isalnum(c) || (c == '+') || (c == '/'));
}
inline bool isBase64U (unsigned char c) {
return (isalnum(c) || (c == '-') || (c == '_'));
}
bool parseHexanumber (char const *inputStr, size_t len, uint32_t * outputInt) {
const uint32_t charVal[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
bool ok = true;
for (size_t j = 0; j < len; j++) {
if (inputStr[j] > '/' && inputStr[j] < ':') {
*outputInt = (*outputInt << 4) | charVal[inputStr[j] - 48];
}
else if (inputStr[j] > '@' && inputStr[j] < 'G') {
*outputInt = (*outputInt << 4) | charVal[inputStr[j] - 55];
}
else if (inputStr[j] > '`' && inputStr[j] < 'g') {
*outputInt = (*outputInt << 4) | charVal[inputStr[j] - 87];
}
else {
// invalid sequence of characters received for now simply return whatever we received
// *outputStr = string(inputStr,len);
ok = false;
break;
}
}
return ok;
}
///-------------------------------------------------------
/// @brief computes the unicode value of an ut16 symbol
///-------------------------------------------------------
bool toUnicode (uint16_t w1, uint16_t w2, uint32_t *v) {
uint32_t vh = w1 - 0xD800;
uint32_t vl = w2 - 0xDC00;
uint32_t vp = (vh << 10) | vl;
*v = vp + 0x10000;
return true;
}
bool toUtf8 (uint32_t outputInt, string & outputStr) {
if ((outputInt >> 7) == 0) {
outputStr.append(1, (char) (outputInt));
}
// unicode sequence is in the range \u0080 to \u07ff
else if ((outputInt >> 11) == 0) {
outputStr.append(1, (char) ((3 << 6) | (outputInt >> 6)));
outputStr.append(1, (char) ((1 << 7) | (outputInt & 63)));
}
// unicode sequence is in the range \u0800 to \uffff
else if ((outputInt >> 16) == 0) {
outputStr.append(1, (char) ((7 << 5) | (outputInt >> 12)));
outputStr.append(1, (char) ((1 << 7) | ((outputInt & 4095 /* 2^12 - 1*/) >> 6)));
outputStr.append(1, (char) ((1 << 7) | (outputInt & 63)));
}
else if ((outputInt >> 21) == 0) {
outputStr.append(1, (char) ((15 << 4) | (outputInt >> 18)));
outputStr.append(1, (char) ((1 << 7) | ((outputInt & 262143 /* 2^18 - 1*/) >> 12)));
outputStr.append(1, (char) ((1 << 7) | ((outputInt & 4095 /* 2^12 - 1*/) >> 6)));
outputStr.append(1, (char) ((1 << 7) | ((outputInt & 63))));
}
else {
// can't handle it yet (need 5,6 etc utf8 characters), just send back the string we got
return false;
}
return true;
}
///-------------------------------------------------------
/// @brief true when number lays in the range
/// U+D800 U+DBFF
///-------------------------------------------------------
bool isHighSurrugate (uint32_t number) {
return (number >= 0xD800) && (number <= 0xDBFF);
}
///-------------------------------------------------------
/// @brief true when number lays in the range
/// U+DC00 U+DFFF
bool isLowSurrugate (uint32_t number) {
return (number >= 0xDC00) && (number <= 0xDFFF);
}
}
namespace triagens {
namespace basics {
namespace StringUtils {
// .............................................................................
// STRING AND STRING POINTER
// .............................................................................
blob_t duplicateBlob (const blob_t& source) {
blob_t result = {0,0};
if (source.length == 0 || source.data == 0) {
return result;
}
result.data = new char[source.length];
memcpy(const_cast<char*>(result.data), source.data, source.length);
result.length = source.length;
return result;
}
blob_t duplicateBlob (char const* source, size_t len) {
blob_t result = {0,0};
if (source == 0 || len == 0) {
return result;
}
result.data = new char[len];
memcpy(const_cast<char*>(result.data), source, len);
result.length = (uint32_t) len;
return result;
}
blob_t duplicateBlob (const string& source) {
blob_t result = {0,0};
if (source.size() == 0) {
return result;
}
result.data = new char[source.size()];
memcpy(const_cast<char*>(result.data), source.c_str(), source.size());
result.length = (uint32_t) source.size();
return result;
}
char* duplicate (string const& source) {
size_t len = source.size();
char* result = new char[len + 1];
memcpy(result, source.c_str(), len);
result[len] = '\0';
return result;
}
char* duplicate (char const* source, size_t len) {
if (source == 0) {
return 0;
}
char* result = new char[len + 1];
memcpy(result, source, len);
result[len] = '\0';
return result;
}
char* duplicate (char const* source) {
if (source == 0) {
return 0;
}
size_t len = strlen(source);
char* result = new char[len + 1];
memcpy(result, source, len);
result[len] = '\0';
return result;
}
void destroy (char*& source) {
if (source != 0) {
::memset(source, 0, ::strlen(source));
delete[] source;
source = 0;
}
}
void destroy (char*& source, size_t length) {
if (source != 0) {
::memset(source, 0, length);
delete[] source;
source = 0;
}
}
void destroy (blob_t& source) {
if (source.data != 0) {
::memset(const_cast<char*>(source.data), 0, source.length);
delete[] source.data;
source.data = 0;
source.length = 0;
}
}
void erase (char*& source) {
if (source != 0) {
delete[] source;
source = 0;
}
}
void erase (blob_t& source) {
if (source.data != 0) {
delete[] source.data;
source.data = 0;
source.length = 0;
}
}
// .............................................................................
// STRING CONVERSION
// .............................................................................
string capitalize (string const& name, bool first) {
size_t len = name.length();
if (len == 0) {
std::string message("name must not be empty");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
char * buffer = new char[len + 1];
char * qtr = buffer;
char const * ptr = name.c_str();
for (; 0 < len && isSpace(*ptr); len--, ptr++) {
}
if (len == 0) {
std::string message("object or attribute name must not be empty");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
bool upper = first;
for (; 0 < len; len--, ptr++) {
if (isSpace(*ptr)) {
upper = true;
}
else {
if (upper) {
*qtr++ = static_cast<char>(::toupper(*ptr));
}
else {
*qtr++ = static_cast<char>(::tolower(*ptr));
}
upper = false;
}
}
*qtr = '\0';
string result(buffer);
delete[] buffer;
return result;
}
string separate (string const& name, char separator) {
size_t len = name.length();
if (len == 0) {
std::string message("name must not be empty");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
char * buffer = new char[len + 1];
char * qtr = buffer;
char const * ptr = name.c_str();
for (; 0 < len && isSpace(*ptr); len--, ptr++) {
}
if (len == 0) {
std::string message("name must not be empty");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
bool useSeparator = false;
for (; 0 < len; len--, ptr++) {
for (; 0 < len && isSpace(*ptr); len--, ptr++) {
useSeparator = true;
}
if (0 < len) {
if (useSeparator) {
*qtr++ = separator;
useSeparator = false;
}
*qtr++ = static_cast<char>(::tolower(*ptr));
}
else {
break;
}
}
*qtr = '\0';
string result(buffer);
delete[] buffer;
return result;
}
string escape (string const& name, string const& special, char quote) {
size_t len = name.length();
if (len == 0) {
return name;
}
if (len >= (SIZE_MAX - 1) / 2) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
char * buffer = new char [2 * len + 1];
char * qtr = buffer;
char const * ptr = name.c_str();
char const * end = ptr + len;
if (special.length() == 0) {
for (; ptr < end; ptr++, qtr++) {
if (*ptr == quote) {
*qtr++ = quote;
}
*qtr = *ptr;
}
}
else if (special.length() == 1) {
char s = special[0];
for (; ptr < end; ptr++, qtr++) {
if (*ptr == quote || *ptr == s) {
*qtr++ = quote;
}
*qtr = *ptr;
}
}
else {
for (; ptr < end; ptr++, qtr++) {
if (*ptr == quote || special.find(*ptr) != string::npos) {
*qtr++ = quote;
}
*qtr = *ptr;
}
}
*qtr = '\0';
string result(buffer, qtr - buffer);
delete[] buffer;
return result;
}
string escape (string const& name, size_t len, string const& special, char quote) {
if (len == 0) {
return name;
}
if (len >= (SIZE_MAX - 1) / 2) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
char * buffer = new char [2 * len + 1];
char * qtr = buffer;
char const * ptr = name.c_str();
char const * end = ptr + len;
if (special.length() == 0) {
for (; ptr < end; ptr++, qtr++) {
if (*ptr == quote) {
*qtr++ = quote;
}
*qtr = *ptr;
}
}
else if (special.length() == 1) {
char s = special[0];
for (; ptr < end; ptr++, qtr++) {
if (*ptr == quote || *ptr == s) {
*qtr++ = quote;
}
*qtr = *ptr;
}
}
else {
for (; ptr < end; ptr++, qtr++) {
if (*ptr == quote || special.find(*ptr) != string::npos) {
*qtr++ = quote;
}
*qtr = *ptr;
}
}
*qtr = '\0';
string result(buffer, qtr - buffer);
delete[] buffer;
return result;
}
string escapeUnicode (string const& name, bool escapeSlash) {
size_t len = name.length();
if (len == 0) {
return name;
}
if (len >= (SIZE_MAX - 1) / 6) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
bool corrupted = false;
char * buffer = new char [6 * len + 1];
char * qtr = buffer;
char const * ptr = name.c_str();
char const * end = ptr + len;
for (; ptr < end; ++ptr, ++qtr) {
switch (*ptr) {
case '/':
if (escapeSlash) {
*qtr++ = '\\';
}
*qtr = *ptr;
break;
case '\\':
case '"':
*qtr++ = '\\';
*qtr = *ptr;
break;
case '\b':
*qtr++ = '\\';
*qtr = 'b';
break;
case '\f':
*qtr++ = '\\';
*qtr = 'f';
break;
case '\n':
*qtr++ = '\\';
*qtr = 'n';
break;
case '\r':
*qtr++ = '\\';
*qtr = 'r';
break;
case '\t':
*qtr++ = '\\';
*qtr = 't';
break;
case '\0':
*qtr++ = '\\';
*qtr++ = 'u';
*qtr++ = '0';
*qtr++ = '0';
*qtr++ = '0';
*qtr = '0';
break;
default:
{
uint8_t c = (uint8_t) *ptr;
// character is in the normal latin1 range
if ((c & 0x80) == 0) {
// special character, escape
if (c < 32) {
*qtr++ = '\\';
*qtr++ = 'u';
*qtr++ = '0';
*qtr++ = '0';
uint16_t i1 = (static_cast<uint16_t>(c) & 0xF0) >> 4;
uint16_t i2 = (static_cast<uint16_t>(c) & 0x0F);
*qtr++ = (i1 < 10) ? ('0' + i1) : ('A' + i1 - 10);
*qtr = (i2 < 10) ? ('0' + i2) : ('A' + i2 - 10);
}
// normal latin1
else {
*qtr = *ptr;
}
}
// unicode range 0080 - 07ff
else if ((c & 0xE0) == 0xC0) {
if (ptr + 1 < end) {
uint8_t d = (uint8_t) *(ptr + 1);
// correct unicode
if ((d & 0xC0) == 0x80) {
++ptr;
*qtr++ = '\\';
*qtr++ = 'u';
uint16_t n = ((c & 0x1F) << 6) | (d & 0x3F);
uint16_t i1 = (n & 0xF000) >> 12;
uint16_t i2 = (n & 0x0F00) >> 8;
uint16_t i3 = (n & 0x00F0) >> 4;
uint16_t i4 = (n & 0x000F);
*qtr++ = (i1 < 10) ? ('0' + i1) : ('A' + i1 - 10);
*qtr++ = (i2 < 10) ? ('0' + i2) : ('A' + i2 - 10);
*qtr++ = (i3 < 10) ? ('0' + i3) : ('A' + i3 - 10);
*qtr = (i4 < 10) ? ('0' + i4) : ('A' + i4 - 10);
}
// corrupted unicode
else {
*qtr = *ptr;
corrupted = true;
}
}
// corrupted unicode
else {
*qtr = *ptr;
corrupted = true;
}
}
// unicode range 0800 - ffff
else if ((c & 0xF0) == 0xE0) {
if (ptr + 1 < end) {
uint8_t d = (uint8_t) *(ptr + 1);
// correct unicode
if ((d & 0xC0) == 0x80) {
if (ptr + 2 < end) {
uint8_t e = (uint8_t) *(ptr + 2);
// correct unicode
if ((e & 0xC0) == 0x80) {
// TODO: if & else branch are the same
*qtr = *ptr;
}
// corrupted unicode
else {
*qtr = *ptr;
corrupted = true;
}
}
// corrupted unicode
else {
*qtr = *ptr;
corrupted = true;
}
}
// corrupted unicode
else {
*qtr = *ptr;
corrupted = true;
}
}
// corrupted unicode
else {
*qtr = *ptr;
corrupted = true;
}
}
// unicode range 010000 - 10ffff -- NOT IMPLEMENTED
else {
*qtr = *ptr;
}
}
break;
}
}
*qtr = '\0';
string result(buffer, qtr - buffer);
delete[] buffer;
if (corrupted) {
LOG_WARNING("escaped corrupted unicode string");
}
return result;
}
string escapeHtml (string const& name) {
size_t len = name.length();
if (len == 0) {
return name;
}
if (len >= (SIZE_MAX - 1) / 8) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
char * buffer = new char [8 * len + 1];
char * qtr = buffer;
char const * ptr = name.c_str();
char const * end = ptr + len;
for (; ptr < end; ++ptr, ++qtr) {
if (*ptr == '<') {
*qtr++ = '&';
*qtr++ = 'l';
*qtr++ = 't';
*qtr = ';';
}
else if (*ptr == '>') {
*qtr++ = '&';
*qtr++ = 'g';
*qtr++ = 't';
*qtr = ';';
}
else if (*ptr == '&') {
*qtr++ = '&';
*qtr++ = 'a';
*qtr++ = 'm';
*qtr++ = 'p';
*qtr = ';';
}
else if (*ptr == '"') {
*qtr++ = '&';
*qtr++ = 'q';
*qtr++ = 'u';
*qtr++ = 'o';
*qtr++ = 't';
*qtr = ';';
}
else {
*qtr = *ptr;
}
}
*qtr = '\0';
string result(buffer, qtr - buffer);
delete[] buffer;
return result;
}
string escapeXml (string const& name) {
return escapeHtml(name);
}
string escapeHex (string const& name, char quote) {
size_t len = name.length();
if (len == 0) {
return name;
}
if (len >= (SIZE_MAX - 1) / 3) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
char * buffer = new char [3 * len + 1];
char * qtr = buffer;
char const * ptr = name.c_str();
char const * end = ptr + len;
for (; ptr < end; ptr++, qtr++) {
if (*ptr == quote || *ptr <= ' ' || static_cast<uint8_t>(*ptr) >= 128) {
uint8_t n = (uint8_t)(*ptr);
uint8_t n1 = n >> 4;
uint8_t n2 = n & 0x0F;
*qtr++ = quote;
*qtr++ = (n1 < 10) ? ('0' + n1) : ('A' + n1 - 10);
*qtr = (n2 < 10) ? ('0' + n2) : ('A' + n2 - 10);
}
else {
*qtr = *ptr;
}
}
*qtr = '\0';
string result(buffer, qtr - buffer);
delete[] buffer;
return result;
}
string escapeHex (string const& name, string const& special, char quote) {
size_t len = name.length();
if (len == 0) {
return name;
}
if (len >= (SIZE_MAX - 1) / 3) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
char * buffer = new char [3 * len + 1];
char * qtr = buffer;
char const * ptr = name.c_str();
char const * end = ptr + len;
if (special.length() == 0) {
for (; ptr < end; ptr++, qtr++) {
if (*ptr == quote) {
uint8_t n = (uint8_t)(*ptr);
uint8_t n1 = n >> 4;
uint8_t n2 = n & 0x0F;
*qtr++ = quote;
*qtr++ = (n1 < 10) ? ('0' + n1) : ('A' + n1 - 10);
*qtr = (n2 < 10) ? ('0' + n2) : ('A' + n2 - 10);
}
else {
*qtr = *ptr;
}
}
}
else if (special.length() == 1) {
char s = special[0];
for (; ptr < end; ptr++, qtr++) {
if (*ptr == quote || *ptr == s) {
uint8_t n = (uint8_t)(*ptr);
uint8_t n1 = n >> 4;
uint8_t n2 = n & 0x0F;
*qtr++ = quote;
*qtr++ = (n1 < 10) ? ('0' + n1) : ('A' + n1 - 10);
*qtr = (n2 < 10) ? ('0' + n2) : ('A' + n2 - 10);
}
else {
*qtr = *ptr;
}
}
}
else {
for (; ptr < end; ptr++, qtr++) {
if (*ptr == quote || special.find(*ptr) != string::npos) {
uint8_t n = (uint8_t)(*ptr);
uint8_t n1 = n >> 4;
uint8_t n2 = n & 0x0F;
*qtr++ = quote;
*qtr++ = (n1 < 10) ? ('0' + n1) : ('A' + n1 - 10);
*qtr = (n2 < 10) ? ('0' + n2) : ('A' + n2 - 10);
}
else {
*qtr = *ptr;
}
}
}
*qtr = '\0';
string result(buffer, qtr - buffer);
delete[] buffer;
return result;
}
string escapeC (string const& name) {
size_t len = name.length();
if (len == 0) {
return name;
}
if (len >= (SIZE_MAX - 1) / 4) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
char * buffer = new char [4 * len + 1];
char * qtr = buffer;
char const * ptr = name.c_str();
char const * end = ptr + len;
for (; ptr < end; ptr++, qtr++) {
uint8_t n = (uint8_t)(*ptr);
switch (*ptr) {
case '\n':
*qtr++ = '\\';
*qtr = 'n';
break;
case '\r':
*qtr++ = '\\';
*qtr = 'r';
break;
case '\'':
case '"':
*qtr++ = '\\';
*qtr = *ptr;
break;
default:
if (n < 32 || n > 127) {
uint8_t n1 = n >> 4;
uint8_t n2 = n & 0x0F;
*qtr++ = '\\';
*qtr++ = 'x';
*qtr++ = (n1 < 10) ? ('0' + n1) : ('A' + n1 - 10);
*qtr = (n2 < 10) ? ('0' + n2) : ('A' + n2 - 10);
}
else {
*qtr = *ptr;
}
break;
}
}
*qtr = '\0';
string result(buffer, qtr - buffer);
delete[] buffer;
return result;
}
vector<string> split (string const& source, char delim, char quote) {
vector<string> result;
if (source.empty()) {
return result;
}
char* buffer = new char[source.size() + 1];
char* p = buffer;
char const* q = source.c_str();
char const* e = source.c_str() + source.size();
if (quote == '\0') {
for (; q < e; ++q) {
if (*q == delim) {
*p = '\0';
result.push_back(string(buffer, p - buffer));
p = buffer;
}
else {
*p++ = *q;
}
}
}
else {
for (; q < e; ++q) {
if (*q == quote) {
if (q + 1 < e) {
*p++ = *++q;
}
}
else if (*q == delim) {
*p = '\0';
result.push_back(string(buffer, p - buffer));
p = buffer;
}
else {
*p++ = *q;
}
}
}
*p = '\0';
result.push_back(string(buffer, p - buffer));
delete[] buffer;
return result;
}
vector<string> split (string const& source, string const& delim, char quote) {
vector<string> result;
if (source.empty()) {
return result;
}
char* buffer = new char[source.size() + 1];
char* p = buffer;
char const* q = source.c_str();
char const* e = source.c_str() + source.size();
if (quote == '\0') {
for (; q < e; ++q) {
if (delim.find(*q) != string::npos) {
*p = '\0';
result.push_back(string(buffer, p - buffer));
p = buffer;
}
else {
*p++ = *q;
}
}
}
else {
for (; q < e; ++q) {
if (*q == quote) {
if (q + 1 < e) {
*p++ = *++q;
}
}
else if (delim.find(*q) != string::npos) {
*p = '\0';
result.push_back(string(buffer, p - buffer));
p = buffer;
}
else {
*p++ = *q;
}
}
}
*p = '\0';
result.push_back(string(buffer, p - buffer));
delete[] buffer;
return result;
}
string join (vector<string> const& source, char delim) {
string result = "";
bool first = true;
for (vector<string>::const_iterator i = source.begin(); i != source.end(); ++i) {
if (first) {
first = false;
}
else {
result += delim;
}
result += *i;
}
return result;
}
string join (vector<string> const& source, string const& delim) {
string result = "";
bool first = true;
for (vector<string>::const_iterator i = source.begin(); i != source.end(); ++i) {
if (first) {
first = false;
}
else {
result += delim;
}
result += *i;
}
return result;
}
string join (set<string> const& source, char delim) {
string result = "";
bool first = true;
for (set<string>::const_iterator i = source.begin(); i != source.end(); ++i) {
if (first) {
first = false;
}
else {
result += delim;
}
result += *i;
}
return result;
}
string join (set<string> const& source, string const& delim) {
string result = "";
bool first = true;
for (set<string>::const_iterator i = source.begin(); i != source.end(); ++i) {
if (first) {
first = false;
}
else {
result += delim;
}
result += *i;
}
return result;
}
string trim (string const& sourceStr, string const& trimStr) {
size_t s = sourceStr.find_first_not_of(trimStr);
size_t e = sourceStr.find_last_not_of(trimStr);
if (s == std::string::npos) {
return string();
}
else {
return string(sourceStr, s, e - s + 1);
}
}
void trimInPlace (string& str, string const& trimStr) {
size_t s = str.find_first_not_of(trimStr);
size_t e = str.find_last_not_of(trimStr);
if (s == std::string::npos) {
str.clear();
}
else if (s == 0 && e == str.length() - 1) {
// nothing to do
}
else if (s == 0) {
str.erase(e + 1);
}
else {
str = str.substr(s, e-s+1);
}
}
string lTrim (string const& str, string const& trimStr) {
size_t s = str.find_first_not_of(trimStr);
if (s == std::string::npos) {
return string();
}
else {
return string(str, s);
}
}
string rTrim (string const& sourceStr, string const& trimStr) {
size_t e = sourceStr.find_last_not_of(trimStr);
return string(sourceStr, 0, e + 1);
}
string lFill (string const& sourceStr, size_t size, char fill) {
size_t l = sourceStr.size();
if (l >= size) {
return sourceStr;
}
return string(size - l, fill) + sourceStr;
}
string rFill (string const& sourceStr, size_t size, char fill) {
size_t l = sourceStr.size();
if (l >= size) {
return sourceStr;
}
return sourceStr + string(size - l, fill);
}
vector<string> wrap (string const& sourceStr, size_t size, string breaks) {
vector<string> result;
string next = sourceStr;
if (size > 0) {
while (next.size() > size) {
size_t m = next.find_last_of(breaks, size - 1);
if (m == string::npos || m < size / 2) {
m = size;
}
else {
m += 1;
}
result.push_back(next.substr(0, m));
next = next.substr(m);
}
}
result.push_back(next);
return result;
}
/// replaces the contents of the sourceStr = "aaebbbbcce" where ever the occurence of
/// fromStr = "bb" exists with the toStr = "dd". No recursion performed on the replaced string
/// e.g. replace("aaebbbbcce","bb","dd") = "aaeddddcce"
/// e.g. replace("aaebbbbcce","bb","bbb") = "aaebbbbbbcce"
/// e.g. replace("aaebbbbcce","bbb","bb") = "aaebbbcce"
string replace (string const& sourceStr, string const& fromStr, string const& toStr) {
size_t fromLength = fromStr.length();
size_t toLength = toStr.length();
size_t sourceLength = sourceStr.length();
// cannot perform a replace if the sourceStr = "" or fromStr = ""
if (fromLength == 0 || sourceLength == 0) {
return sourceStr;
}
// the max amount of memory is:
size_t mt = max(static_cast<size_t>(1),toLength);
if ((sourceLength / fromLength) + 1 >= (SIZE_MAX - toLength) / mt) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
size_t maxLength = (((sourceLength / fromLength) + 1) * mt) + toLength;
// the min amount of memory we have to allocate for the "replace" (new) string is length of sourceStr
maxLength = max(maxLength, sourceLength) + 1;
char* result = new char[maxLength];
size_t k = 0;
for (size_t j = 0; j < sourceLength; ++j) {
bool match = true;
for (size_t i = 0; i < fromLength; ++i) {
if (sourceStr[j + i] != fromStr[i]) {
match = false;
break;
}
}
if (! match) {
result[k] = sourceStr[j];
++k;
continue;
}
for (size_t i = 0; i < toLength; ++i) {
result[k] = toStr[i];
++k;
}
j += (fromLength - 1);
}
result[k] = '\0';
string retStr(result);
delete[] result;
return retStr;
}
void tolowerInPlace (string* str) {
size_t len = str->length();
if (len == 0) {
return;
}
for (string::iterator i = str->begin(); i != str->end(); ++i) {
*i = ::tolower(*i);
}
}
string tolower (string const& str) {
size_t len = str.length();
if (len == 0) {
return "";
}
char * buffer = new char[len];
char * qtr = buffer;
char const * ptr = str.c_str();
for (; 0 < len; len--, ptr++, qtr++) {
*qtr = static_cast<char>(::tolower(*ptr));
}
string result(buffer, str.size());
delete[] buffer;
return result;
}
void toupperInPlace (string* str) {
size_t len = str->length();
if (len == 0) {
return;
}
for (string::iterator i = str->begin(); i != str->end(); ++i) {
*i = ::toupper(*i);
}
}
string toupper (string const& str) {
size_t len = str.length();
if (len == 0) {
return "";
}
char * buffer = new char[len];
char * qtr = buffer;
char const * ptr = str.c_str();
for (; 0 < len; len--, ptr++, qtr++) {
*qtr = static_cast<char>(::toupper(*ptr));
}
string result(buffer, str.size());
delete[] buffer;
return result;
}
bool isPrefix (string const& str, string const& prefix) {
if (prefix.length() > str.length()) {
return false;
}
else if (prefix.length() == str.length()) {
return str == prefix;
}
else {
return str.compare(0, prefix.length(), prefix) == 0;
}
}
bool isSuffix (string const& str, string const& postfix) {
if (postfix.length() > str.length()) {
return false;
}
else if (postfix.length() == str.length()) {
return str == postfix;
}
else {
return str.compare(str.size() - postfix.length(), postfix.length(), postfix) == 0;
}
}
string urlDecode (string const& str) {
char const* src = str.c_str();
char const* end = src + str.size();
char* buffer = new char[str.size() + 1];
char* ptr = buffer;
for (; src < end && *src != '%'; ++src) {
if (*src == '+') {
*ptr++ = ' ';
}
else {
*ptr++ = *src;
}
}
while (src < end) {
if (src + 2 < end) {
int h1 = hex2int(src[1], -1);
int h2 = hex2int(src[2], -1);
if (h1 == -1) {
src += 1;
}
else {
if (h2 == -1) {
*ptr++ = h1;
src += 2;
}
else {
*ptr++ = h1 << 4 | h2;
src += 3;
}
}
}
else if (src + 1 < end) {
int h1 = hex2int(src[1], -1);
if (h1 == -1) {
src += 1;
}
else {
*ptr++ = h1;
src += 2;
}
}
else {
src += 1;
}
for (; src < end && *src != '%'; ++src) {
if (*src == '+') {
*ptr++ = ' ';
}
else {
*ptr++ = *src;
}
}
}
*ptr = '\0';
string result(buffer, ptr - buffer);
delete[] buffer;
return result;
}
string urlEncode (string const& str) {
return urlEncode(str.c_str(), str.size());
}
string urlEncode (const char* src) {
if (src != 0) {
size_t len = strlen(src);
return urlEncode(src, len);
}
return "";
}
string urlEncode (const char* src, const size_t len) {
static char hexChars[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
char const* end = src + len;
if (len >= (SIZE_MAX - 1) / 3) {
THROW_ARANGO_EXCEPTION(TRI_ERROR_OUT_OF_MEMORY);
}
char* buffer = new char[3 * len + 1];
char* ptr = buffer;
for (; src < end; ++src) {
if ('0' <= *src && *src <= '9') {
*ptr++ = *src;
}
else if ('a' <= *src && *src <= 'z') {
*ptr++ = *src;
}
else if ('A' <= *src && *src <= 'Z') {
*ptr++ = *src;
}
else if (*src == '-' || *src == '_' || *src == '.' || *src == '~') {
*ptr++ = *src;
}
else {
uint8_t n = (uint8_t)(*src);
uint8_t n1 = n >> 4;
uint8_t n2 = n & 0x0F;
*ptr++ = '%';
*ptr++ = hexChars[n1];
*ptr++ = hexChars[n2];
}
}
*ptr = '\0';
string result(buffer, ptr - buffer);
delete[] buffer;
return result;
}
// .............................................................................
// CONVERT TO STRING
// .............................................................................
string itoa (int16_t attr) {
char buffer[7];
char* p = buffer;
if (attr == INT16_MIN) {
return "-32768";
}
if (attr < 0) {
*p++ = '-';
attr = -attr;
}
if ( 10000L <= attr) { *p++ = char((attr / 10000L) % 10 + '0'); }
if ( 1000L <= attr) { *p++ = char((attr / 1000L) % 10 + '0'); }
if ( 100L <= attr) { *p++ = char((attr / 100L) % 10 + '0'); }
if ( 10L <= attr) { *p++ = char((attr / 10L) % 10 + '0'); }
*p++ = char(attr % 10 + '0');
*p = '\0';
return buffer;
}
string itoa (uint16_t attr) {
char buffer[6];
char* p = buffer;
if ( 10000L <= attr) { *p++ = char((attr / 10000L) % 10 + '0'); }
if ( 1000L <= attr) { *p++ = char((attr / 1000L) % 10 + '0'); }
if ( 100L <= attr) { *p++ = char((attr / 100L) % 10 + '0'); }
if ( 10L <= attr) { *p++ = char((attr / 10L) % 10 + '0'); }
*p++ = char(attr % 10 + '0');
*p = '\0';
return buffer;
}
string itoa (int32_t attr) {
char buffer[12];
char* p = buffer;
if (attr == INT32_MIN) {
return "-2147483648";
}
if (attr < 0) {
*p++ = '-';
attr = -attr;
}
if (1000000000L <= attr) { *p++ = char((attr / 1000000000L) % 10 + '0'); }
if ( 100000000L <= attr) { *p++ = char((attr / 100000000L) % 10 + '0'); }
if ( 10000000L <= attr) { *p++ = char((attr / 10000000L) % 10 + '0'); }
if ( 1000000L <= attr) { *p++ = char((attr / 1000000L) % 10 + '0'); }
if ( 100000L <= attr) { *p++ = char((attr / 100000L) % 10 + '0'); }
if ( 10000L <= attr) { *p++ = char((attr / 10000L) % 10 + '0'); }
if ( 1000L <= attr) { *p++ = char((attr / 1000L) % 10 + '0'); }
if ( 100L <= attr) { *p++ = char((attr / 100L) % 10 + '0'); }
if ( 10L <= attr) { *p++ = char((attr / 10L) % 10 + '0'); }
*p++ = char(attr % 10 + '0');
*p = '\0';
return buffer;
}
string itoa (uint32_t attr) {
char buffer[11];
char* p = buffer;
if (1000000000L <= attr) { *p++ = char((attr / 1000000000L) % 10 + '0'); }
if ( 100000000L <= attr) { *p++ = char((attr / 100000000L) % 10 + '0'); }
if ( 10000000L <= attr) { *p++ = char((attr / 10000000L) % 10 + '0'); }
if ( 1000000L <= attr) { *p++ = char((attr / 1000000L) % 10 + '0'); }
if ( 100000L <= attr) { *p++ = char((attr / 100000L) % 10 + '0'); }
if ( 10000L <= attr) { *p++ = char((attr / 10000L) % 10 + '0'); }
if ( 1000L <= attr) { *p++ = char((attr / 1000L) % 10 + '0'); }
if ( 100L <= attr) { *p++ = char((attr / 100L) % 10 + '0'); }
if ( 10L <= attr) { *p++ = char((attr / 10L) % 10 + '0'); }
*p++ = char(attr % 10 + '0');
*p = '\0';
return buffer;
}
string itoa (int64_t attr) {
char buffer[21];
char* p = buffer;
if (attr == INT64_MIN) {
return "-9223372036854775808";
}
if (attr < 0) {
*p++ = '-';
attr = -attr;
}
if (1000000000000000000LL <= attr) { *p++ = char((attr / 1000000000000000000LL) % 10 + '0'); }
if ( 100000000000000000LL <= attr) { *p++ = char((attr / 100000000000000000LL) % 10 + '0'); }
if ( 10000000000000000LL <= attr) { *p++ = char((attr / 10000000000000000LL) % 10 + '0'); }
if ( 1000000000000000LL <= attr) { *p++ = char((attr / 1000000000000000LL) % 10 + '0'); }
if ( 100000000000000LL <= attr) { *p++ = char((attr / 100000000000000LL) % 10 + '0'); }
if ( 10000000000000LL <= attr) { *p++ = char((attr / 10000000000000LL) % 10 + '0'); }
if ( 1000000000000LL <= attr) { *p++ = char((attr / 1000000000000LL) % 10 + '0'); }
if ( 100000000000LL <= attr) { *p++ = char((attr / 100000000000LL) % 10 + '0'); }
if ( 10000000000LL <= attr) { *p++ = char((attr / 10000000000LL) % 10 + '0'); }
if ( 1000000000LL <= attr) { *p++ = char((attr / 1000000000LL) % 10 + '0'); }
if ( 100000000LL <= attr) { *p++ = char((attr / 100000000LL) % 10 + '0'); }
if ( 10000000LL <= attr) { *p++ = char((attr / 10000000LL) % 10 + '0'); }
if ( 1000000LL <= attr) { *p++ = char((attr / 1000000LL) % 10 + '0'); }
if ( 100000LL <= attr) { *p++ = char((attr / 100000LL) % 10 + '0'); }
if ( 10000LL <= attr) { *p++ = char((attr / 10000LL) % 10 + '0'); }
if ( 1000LL <= attr) { *p++ = char((attr / 1000LL) % 10 + '0'); }
if ( 100LL <= attr) { *p++ = char((attr / 100LL) % 10 + '0'); }
if ( 10LL <= attr) { *p++ = char((attr / 10LL) % 10 + '0'); }
*p++ = char(attr % 10 + '0');
*p = '\0';
return buffer;
}
string itoa (uint64_t attr) {
char buffer[21];
char* p = buffer;
if (10000000000000000000ULL <= attr) { *p++ = char((attr / 10000000000000000000ULL) % 10 + '0'); }
if ( 1000000000000000000ULL <= attr) { *p++ = char((attr / 1000000000000000000ULL) % 10 + '0'); }
if ( 100000000000000000ULL <= attr) { *p++ = char((attr / 100000000000000000ULL) % 10 + '0'); }
if ( 10000000000000000ULL <= attr) { *p++ = char((attr / 10000000000000000ULL) % 10 + '0'); }
if ( 1000000000000000ULL <= attr) { *p++ = char((attr / 1000000000000000ULL) % 10 + '0'); }
if ( 100000000000000ULL <= attr) { *p++ = char((attr / 100000000000000ULL) % 10 + '0'); }
if ( 10000000000000ULL <= attr) { *p++ = char((attr / 10000000000000ULL) % 10 + '0'); }
if ( 1000000000000ULL <= attr) { *p++ = char((attr / 1000000000000ULL) % 10 + '0'); }
if ( 100000000000ULL <= attr) { *p++ = char((attr / 100000000000ULL) % 10 + '0'); }
if ( 10000000000ULL <= attr) { *p++ = char((attr / 10000000000ULL) % 10 + '0'); }
if ( 1000000000ULL <= attr) { *p++ = char((attr / 1000000000ULL) % 10 + '0'); }
if ( 100000000ULL <= attr) { *p++ = char((attr / 100000000ULL) % 10 + '0'); }
if ( 10000000ULL <= attr) { *p++ = char((attr / 10000000ULL) % 10 + '0'); }
if ( 1000000ULL <= attr) { *p++ = char((attr / 1000000ULL) % 10 + '0'); }
if ( 100000ULL <= attr) { *p++ = char((attr / 100000ULL) % 10 + '0'); }
if ( 10000ULL <= attr) { *p++ = char((attr / 10000ULL) % 10 + '0'); }
if ( 1000ULL <= attr) { *p++ = char((attr / 1000ULL) % 10 + '0'); }
if ( 100ULL <= attr) { *p++ = char((attr / 100ULL) % 10 + '0'); }
if ( 10ULL <= attr) { *p++ = char((attr / 10ULL) % 10 + '0'); }
*p++ = char(attr % 10 + '0');
*p = '\0';
return buffer;
}
string ftoa (double i) {
StringBuffer buffer(TRI_CORE_MEM_ZONE);
buffer.appendDecimal(i);
string result(buffer.c_str());
return result;
}
// .............................................................................
// CONVERT FROM STRING
// .............................................................................
bool boolean (string const& str) {
string lower = tolower(trim(str));
if (lower == "true" || lower == "yes" || lower == "on" || lower == "y" || lower == "1") {
return true;
}
else {
return false;
}
}
int64_t int64 (string const& str) {
#ifdef TRI_HAVE_STRTOLL_R
struct reent buffer;
return strtoll_r(&buffer, str.c_str(), 0, 10);
#else
#ifdef TRI_HAVE__STRTOLL_R
struct reent buffer;
return _strtoll_r(&buffer, str.c_str(), 0, 10);
#else
#ifdef TRI_HAVE_STRTOLL
return strtoll(str.c_str(), 0, 10);
#else
return stoll(str, 0, 10);
#endif
#endif
#endif
}
int64_t int64 (char const* value, size_t size) {
char tmp[22];
if (value[size] != '\0') {
if (size >= sizeof(tmp)) {
size = sizeof(tmp) - 1;
}
memcpy(tmp, value, size);
tmp[size] = '\0';
value = tmp;
}
#ifdef TRI_HAVE_STRTOLL_R
struct reent buffer;
return strtoll_r(&buffer, value, 0, 10);
#else
#ifdef TRI_HAVE__STRTOLL_R
struct reent buffer;
return _strtoll_r(&buffer, value, 0, 10);
#else
#ifdef TRI_HAVE_STRTOLL
return strtoll(value, 0, 10);
#else
return stoll(string(value, size), 0, 10);
#endif
#endif
#endif
}
uint64_t uint64 (string const& str) {
#ifdef TRI_HAVE_STRTOULL_R
struct reent buffer;
return strtoull_r(&buffer, str.c_str(), 0, 10);
#else
#ifdef TRI_HAVE__STRTOULL_R
struct reent buffer;
return _strtoull_r(&buffer, str.c_str(), 0, 10);
#else
#ifdef TRI_HAVE_STRTOULL
return strtoull(str.c_str(), 0, 10);
#else
return stoull(str, 0, 10);
#endif
#endif
#endif
}
uint64_t uint64 (char const* value, size_t size) {
char tmp[22];
if (value[size] != '\0') {
if (size >= sizeof(tmp)) {
size = sizeof(tmp) - 1;
}
memcpy(tmp, value, size);
tmp[size] = '\0';
value = tmp;
}
#ifdef TRI_HAVE_STRTOULL_R
struct reent buffer;
return strtoull_r(&buffer, value, 0, 10);
#else
#ifdef TRI_HAVE__STRTOULL_R
struct reent buffer;
return _strtoull_r(&buffer, value, 0, 10);
#else
#ifdef TRI_HAVE_STRTOULL
return strtoull(value, 0, 10);
#else
return stoull(string(value, size), 0, 10);
#endif
#endif
#endif
}
int32_t int32 (string const& str) {
#ifdef TRI_HAVE_STRTOL_R
struct reent buffer;
return strtol_r(&buffer, str.c_str(), 0, 10);
#else
#ifdef TRI_HAVE__STRTOL_R
struct reent buffer;
return _strtol_r(&buffer, str.c_str(), 0, 10);
#else
return strtol(str.c_str(), 0, 10);
#endif
#endif
}
int32_t int32 (char const* value, size_t size) {
char tmp[22];
if (value[size] != '\0') {
if (size >= sizeof(tmp)) {
size = sizeof(tmp) - 1;
}
memcpy(tmp, value, size);
tmp[size] = '\0';
value = tmp;
}
#ifdef TRI_HAVE_STRTOL_R
struct reent buffer;
return strtol_r(&buffer, value, 0, 10);
#else
#ifdef TRI_HAVE__STRTOL_R
struct reent buffer;
return _strtol_r(&buffer, value, 0, 10);
#else
return strtol(value, 0, 10);
#endif
#endif
}
uint32_t uint32 (string const& str) {
#ifdef TRI_HAVE_STRTOUL_R
struct reent buffer;
return strtoul_r(&buffer, str.c_str(), 0, 10);
#else
#ifdef TRI_HAVE__STRTOUL_R
struct reent buffer;
return _strtoul_r(&buffer, str.c_str(), 0, 10);
#else
return strtoul(str.c_str(), 0, 10);
#endif
#endif
}
uint32_t unhexUint32 (string const& str) {
#ifdef TRI_HAVE_STRTOUL_R
struct reent buffer;
return strtoul_r(&buffer, str.c_str(), 0, 16);
#else
#ifdef TRI_HAVE__STRTOUL_R
struct reent buffer;
return _strtoul_r(&buffer, str.c_str(), 0, 16);
#else
return strtoul(str.c_str(), 0, 16);
#endif
#endif
}
uint32_t uint32 (char const* value, size_t size) {
char tmp[22];
if (value[size] != '\0') {
if (size >= sizeof(tmp)) {
size = sizeof(tmp) - 1;
}
memcpy(tmp, value, size);
tmp[size] = '\0';
value = tmp;
}
#ifdef TRI_HAVE_STRTOUL_R
struct reent buffer;
return strtoul_r(&buffer, value, 0, 10);
#else
#ifdef TRI_HAVE__STRTOUL_R
struct reent buffer;
return _strtoul_r(&buffer, value, 0, 10);
#else
return strtoul(value, 0, 10);
#endif
#endif
}
uint32_t unhexUint32 (char const* value, size_t size) {
char tmp[22];
if (value[size] != '\0') {
if (size >= sizeof(tmp)) {
size = sizeof(tmp) - 1;
}
memcpy(tmp, value, size);
tmp[size] = '\0';
value = tmp;
}
#ifdef TRI_HAVE_STRTOUL_R
struct reent buffer;
return strtoul_r(&buffer, value, 0, 16);
#else
#ifdef TRI_HAVE__STRTOUL_R
struct reent buffer;
return _strtoul_r(&buffer, value, 0, 16);
#else
return strtoul(value, 0, 16);
#endif
#endif
}
double doubleDecimal (string const& str) {
return doubleDecimal(str.c_str(), str.size());
}
double doubleDecimal (char const* value, size_t size) {
double v = 0.0;
double e = 1.0;
bool seenDecimalPoint = false;
uint8_t const* ptr = reinterpret_cast<uint8_t const*>(value);
uint8_t const* end = ptr + size;
// check for the sign first
if (*ptr == '-') {
e = -e;
++ptr;
}
else if (*ptr == '+') {
++ptr;
}
for (; ptr < end; ++ptr) {
uint8_t n = *ptr;
if (n == '.' && ! seenDecimalPoint) {
seenDecimalPoint = true;
continue;
}
if ('9' < n || n < '0') {
break;
}
v = v * 10.0 + (n - 48);
if (seenDecimalPoint) {
e = e * 10.0;
}
}
// we have reached the end without an exponent
if (ptr == end) {
return v / e;
}
// invalid decimal representation
if (*ptr != 'e' && *ptr != 'E') {
return 0.0;
}
++ptr; // move past the 'e' or 'E'
int32_t expSign = 1;
int32_t expValue = 0;
// is there an exponent sign?
if (*ptr == '-') {
expSign = -1;
++ptr;
}
else if (*ptr == '+') {
++ptr;
}
for (; ptr < end; ++ptr) {
uint8_t n = *ptr;
if ('9' < n || n < '0') {
return 0.0;
}
expValue = expValue * 10 + (n - 48);
}
expValue = expValue * expSign;
return (v / e) * pow(10.0, double(expValue));
}
float floatDecimal (string const& str) {
return floatDecimal(str.c_str(), str.size());
}
float floatDecimal (char const* value, size_t size) {
return (float) doubleDecimal(value, size);
}
seconds_t seconds (string const& format, string const& str) {
int32_t hour = 0;
int32_t minute = 0;
int32_t second = 0;
char const * f = format.c_str();
char const * s = str.c_str();
while (*f) {
if (*f == 'H') {
if (strncmp(f, "HH", 2) == 0) {
hour = matchInteger(s, 2);
f += 2;
}
else {
std::string message("unknown time format '" + string(f) + "', expecting 'HH'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
else if (*f == 'M') {
if (strncmp(f, "MI", 2) == 0) {
minute = matchInteger(s, 2);
f += 2;
}
else {
std::string message("unknown time format '" + string(f) + "', expecting 'MI'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
else if (*f == 'S') {
if (strncmp(f, "SSS", 3) == 0) {
int32_t seconds = matchInteger(s);
f += 3;
hour = (seconds / 3600);
minute = (seconds / 60) % 60;
second = (seconds ) % 60;
}
else if (strncmp(f, "SS", 2) == 0) {
second = matchInteger(s, 2);
f += 2;
}
else {
std::string message("unknown time format '" + string(f) + "', expecting 'SS'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
else if (*f == *s) {
f++;
s++;
}
else {
std::string message("cannot match time '" + str + "' with format '" + format + "'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
if (23 < hour || hour < 0) {
std::string message("illegal hour '" + itoa(hour) + "'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
if (59 < minute || minute < 0) {
std::string message("illegal minute '" + itoa(minute) + "'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
if (59 < second || second < 0) {
std::string message("illegal second '" + itoa(second) + "'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
return hour * 3600 + minute * 60 + second;
}
string formatSeconds (seconds_t date) {
int hour = date / 3600;
int minute = (date / 60) % 60;
int second = date % 60;
StringBuffer buffer(TRI_CORE_MEM_ZONE);
buffer.appendInteger2(hour);
buffer.appendChar(':');
buffer.appendInteger2(minute);
buffer.appendChar(':');
buffer.appendInteger2(second);
string result(buffer.c_str());
return result;
}
string formatSeconds (string const& format, seconds_t date) {
return formatDateTime(format, 0, date);
}
date_t date (string const& format, string const& str) {
int32_t year = 1970;
int32_t month = 1;
int32_t day = 1;
char const * f = format.c_str();
char const * s = str.c_str();
while (*f) {
if (*f == 'Y') {
if (strncmp(f, "YYYY", 4) == 0) {
year = matchInteger(s, 4);
f += 4;
}
else {
std::string message("unknown date format '" + string(f) + "', expecting 'YYYY'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
else if (*f == 'M') {
if (strncmp(f, "MM", 2) == 0) {
month = matchInteger(s, 2);
f += 2;
}
else {
std::string message("unknown date format '" + string(f) + "', expecting 'MM'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
else if (*f == 'D') {
if (strncmp(f, "DD", 2) == 0) {
day = matchInteger(s, 2);
f += 2;
}
else {
std::string message("unknown date format '" + string(f) + "', expecting 'DD'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
else if (*f == *s) {
f++;
s++;
}
else {
std::string message("cannot match date '" + str + "' with format '" + format + "'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
if (12 < month || month < 1) {
std::string message("illegal month '" + itoa(month) + "'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
if (31 < day || day < 1) {
std::string message("illegal day '" + itoa(day) + "'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
struct tm t;
t.tm_sec = 0;
t.tm_min = 0;
t.tm_hour = 0;
t.tm_mday = day;
t.tm_mon = month - 1;
t.tm_year = year - 1900;
t.tm_isdst = 0;
return date_t((mktime(&t) - GLOBAL_TIMEZONE) / 86400);
}
string formatDate (date_t date) {
time_t ti = date * 86400;
#ifdef TRI_HAVE_GMTIME_R
struct tm t;
gmtime_r(&ti, &t);
#else
#ifdef TRI_HAVE_GMTIME_S
struct tm t;
gmtime_s(&t, &ti);
#else
struct tm t;
struct tm* tp = gmtime(&ti);
if (tp != 0) {
memcpy(&t, tp, sizeof(struct tm));
}
#endif
#endif
StringBuffer buffer(TRI_CORE_MEM_ZONE);
buffer.appendInteger4(t.tm_year + 1900);
buffer.appendChar('-');
buffer.appendInteger2(t.tm_mon + 1);
buffer.appendChar('-');
buffer.appendInteger2(t.tm_mday);
string result(buffer.c_str());
return result;
}
string formatDate (string const& format, date_t date) {
return formatDateTime(format, date, 0);
}
datetime_t datetime (string const& format, string const& str) {
int32_t year = 1970;
int32_t month = 1;
int32_t day = 1;
int32_t hour = 0;
int32_t minute = 0;
int32_t second = 0;
char const * f = format.c_str();
char const * s = str.c_str();
while (*f) {
if (*f == 'Y') {
if (strncmp(f, "YYYY", 4) == 0) {
year = matchInteger(s, 4);
f += 4;
}
else {
std::string message("unknown date format '" + string(f) + "', expecting 'YYYY'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
else if (*f == 'M') {
if (strncmp(f, "MM", 2) == 0) {
month = matchInteger(s, 2);
f += 2;
}
else if (strncmp(f, "MI", 2) == 0) {
minute = matchInteger(s, 2);
f += 2;
}
else {
std::string message("unknown date format '" + string(f) + "', expecting 'MM'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
else if (*f == 'D') {
if (strncmp(f, "DD", 2) == 0) {
day = matchInteger(s, 2);
f += 2;
}
else {
std::string message("unknown date format '" + string(f) + "', expecting 'DD'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
else if (*f == 'H') {
if (strncmp(f, "HH", 2) == 0) {
hour = matchInteger(s, 2);
f += 2;
}
else {
std::string message("unknown time format '" + string(f) + "', expecting 'HH'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
else if (*f == 'S') {
if (strncmp(f, "SSSSS", 5) == 0) {
time_t seconds = matchInteger(s);
f += 5;
#ifdef TRI_HAVE_GMTIME_R
struct tm t;
time_t ts = seconds;
gmtime_r(&ts, &t);
#else
#ifdef TRI_HAVE_GMTIME_S
struct tm t;
time_t ts = seconds;
gmtime_s(&t, &ts);
#else
struct tm t;
time_t ts = seconds;
struct tm* tp = gmtime(&ts);
if (tp != 0) {
memcpy(&t, tp, sizeof(struct tm));
}
#endif
#endif
second = t.tm_sec;
minute = t.tm_min;
hour = t.tm_hour;
day = t.tm_mday;
month = t.tm_mon + 1;
year = t.tm_year + 1900;
}
else if (strncmp(f, "SSS", 3) == 0) {
int32_t seconds = matchInteger(s);
f += 3;
hour = (seconds / 3600);
minute = (seconds / 60) % 60;
second = (seconds ) % 60;
}
else if (strncmp(f, "SS", 2) == 0) {
second = matchInteger(s, 2);
f += 2;
}
else {
std::string message("unknown time format '" + string(f) + "', expecting 'SS'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
else if (*f == *s) {
f++;
s++;
}
else {
std::string message("cannot match date '" + str + "' with format '" + format + "'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
}
if (12 < month || month < 1) {
std::string message("illegal month'" + itoa(month) + "'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
if (31 < day || day < 1) {
std::string message("illegal day '" + itoa(day) + "'");
THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, message);
}
struct tm t;
t.tm_sec = second;
t.tm_min = minute;
t.tm_hour = hour;
t.tm_mday = day;
t.tm_mon = month - 1;
t.tm_year = year - 1900;
t.tm_isdst = 0;
return datetime_t((mktime(&t) - GLOBAL_TIMEZONE));
}
string formatDatetime (datetime_t datetime) {
int64_t cnv = static_cast<int64_t>(datetime);
date_t d = date_t(cnv / 86400LL);
seconds_t s = seconds_t(cnv % 86400LL);
return formatDateTime(d, s);
}
string formatDatetime (string const& format, datetime_t datetime) {
int64_t cnv = static_cast<int64_t>(datetime);
date_t d = date_t(cnv / 86400LL);
seconds_t s = seconds_t(cnv % 86400LL);
return formatDateTime(format, d, s);
}
string formatDateTime (date_t date, seconds_t time) {
time_t ti = date * 86400;
#ifdef TRI_HAVE_GMTIME_R
struct tm t;
gmtime_r(&ti, &t);
#else
#ifdef TRI_HAVE_GMTIME_S
struct tm t;
gmtime_s(&t, &ti);
#else
struct tm t;
struct tm* tp = gmtime(&ti);
if (tp != 0) {
memcpy(&t, tp, sizeof(struct tm));
}
#endif
#endif
int hour = time / 3600;
int minute = (time / 60) % 60;
int second = time % 60;
StringBuffer buffer(TRI_CORE_MEM_ZONE);
buffer.appendInteger4(t.tm_year + 1900);
buffer.appendChar('-');
buffer.appendInteger2(t.tm_mon + 1);
buffer.appendChar('-');
buffer.appendInteger2(t.tm_mday);
buffer.appendChar('T');
buffer.appendInteger2(hour);
buffer.appendChar(':');
buffer.appendInteger2(minute);
buffer.appendChar(':');
buffer.appendInteger2(second);
string result(buffer.c_str());
return result;
}
string formatDateTime (string const& format, date_t date, seconds_t time) {
time_t ti = date * 86400;
#ifdef TRI_HAVE_GMTIME_R
struct tm t;
gmtime_r(&ti, &t);
#else
#ifdef TRI_HAVE_GMTIME_S
struct tm t;
gmtime_s(&t, &ti);
#else
struct tm t;
struct tm* tp = gmtime(&ti);
if (tp != 0) {
memcpy(&t, tp, sizeof(struct tm));
}
#endif
#endif
int year = t.tm_year + 1900;
int month = t.tm_mon + 1;
int day = t.tm_mday;
int wday = t.tm_wday + 1;
int yday = t.tm_yday + 1;
int hour = time / 3600;
int minute = (time / 60) % 60;
int second = time % 60;
StringBuffer buffer(TRI_CORE_MEM_ZONE);
char const* p = format.c_str();
char const* e = p + format.size();
for (; p < e; ++p) {
// .............................................................................
// quote
// .............................................................................
if (p[0] == '"') {
for (++p; p[0] != '"' && p < e; ++p) {
buffer.appendChar(p[0]);
}
continue;
}
// .............................................................................
// YYYY, YYY, YY, or Y
// .............................................................................
if (p[0] == 'Y' || p[0] == 'y') {
// YYYY, YYY, or YY
if (p + 1 < e && (p[1] == 'Y' || p[1] == 'y')) {
// YYYY or YYY
if (p + 2 < e && (p[2] == 'Y' || p[2] == 'y')) {
// YYYY
if (p + 3 < e && (p[3] == 'Y' || p[3] == 'y')) {
buffer.appendInteger4(year);
p += 3;
}
// YYY
else {
buffer.appendInteger3(year % 1000);
p += 2;
}
}
// YY
else {
buffer.appendInteger2(year % 100);
p += 1;
}
}
// Y
else {
buffer.appendChar((year % 10) + '0');
}
continue;
}
// .............................................................................
// MM, MONTH, MON, MI
// .............................................................................
if (p[0] == 'M' || p[0] == 'm') {
// MM
if (p + 1 < e && (p[1] == 'M' || p[1] == 'm')) {
buffer.appendInteger2(month);
p += 1;
continue;
}
// MI
else if (p + 1 < e && (p[1] == 'I' || p[1] == 'i')) {
buffer.appendInteger2(minute);
p += 1;
continue;
}
// MONTH
else if (p + 4 < e && strcasecmp(p + 1, "onth") == 0) {
if (p[1] == 'O') {
switch (month) {
case 1: buffer.appendText("JANUARY"); break;
case 2: buffer.appendText("FEBRUARY"); break;
case 3: buffer.appendText("MARCH"); break;
case 4: buffer.appendText("APRIL"); break;
case 5: buffer.appendText("MAY"); break;
case 6: buffer.appendText("JUNE"); break;
case 7: buffer.appendText("JULY"); break;
case 8: buffer.appendText("AUGUST"); break;
case 9: buffer.appendText("SEPTEMBER"); break;
case 10: buffer.appendText("OCTOBER"); break;
case 11: buffer.appendText("NOVEMBER"); break;
case 12: buffer.appendText("DECEMBER"); break;
default: buffer.appendText("UNDEFINED"); break;
}
}
else {
switch (month) {
case 1: buffer.appendText("January"); break;
case 2: buffer.appendText("February"); break;
case 3: buffer.appendText("March"); break;
case 4: buffer.appendText("April"); break;
case 5: buffer.appendText("May"); break;
case 6: buffer.appendText("June"); break;
case 7: buffer.appendText("July"); break;
case 8: buffer.appendText("August"); break;
case 9: buffer.appendText("September"); break;
case 10: buffer.appendText("October"); break;
case 11: buffer.appendText("November"); break;
case 12: buffer.appendText("December"); break;
default: buffer.appendText("Undefined"); break;
}
}
p += 4;
continue;
}
// MON
else if (p + 2 < e && strcasecmp(p + 1, "on") == 0) {
if (p[1] == 'O') {
switch (month) {
case 1: buffer.appendText("JAN"); break;
case 2: buffer.appendText("FEB"); break;
case 3: buffer.appendText("MAR"); break;
case 4: buffer.appendText("APR"); break;
case 5: buffer.appendText("MAY"); break;
case 6: buffer.appendText("JUN"); break;
case 7: buffer.appendText("JUL"); break;
case 8: buffer.appendText("AUG"); break;
case 9: buffer.appendText("SEP"); break;
case 10: buffer.appendText("OCT"); break;
case 11: buffer.appendText("NOV"); break;
case 12: buffer.appendText("DEC"); break;
default: buffer.appendText("UDF"); break;
}
}
else {
switch (month) {
case 1: buffer.appendText("Jan"); break;
case 2: buffer.appendText("Feb"); break;
case 3: buffer.appendText("Mar"); break;
case 4: buffer.appendText("Apr"); break;
case 5: buffer.appendText("May"); break;
case 6: buffer.appendText("Jun"); break;
case 7: buffer.appendText("Jul"); break;
case 8: buffer.appendText("Aug"); break;
case 9: buffer.appendText("Sep"); break;
case 10: buffer.appendText("Oct"); break;
case 11: buffer.appendText("Nov"); break;
case 12: buffer.appendText("Dec"); break;
default: buffer.appendText("Udf"); break;
}
}
p += 2;
continue;
}
}
// .............................................................................
// DAY, D, DD, DDD, DY
// .............................................................................
if (p[0] == 'D' || p[0] == 'd') {
// DDD, DD
if (p + 1 < e && (p[1] == 'D' || p[1] == 'd')) {
// DDD
if (p + 2 < e && (p[2] == 'D' || p[2] == 'd')) {
buffer.appendInteger3(yday);
p += 2;
}
// DD
else {
buffer.appendInteger2(day);
p += 1;
}
}
// DY
else if (p + 1 < e && (p[1] == 'Y' || p[1] == 'y')) {
if (p[1] == 'Y') {
switch (wday) {
case 1: buffer.appendText("SUN"); break;
case 2: buffer.appendText("MON"); break;
case 3: buffer.appendText("TUE"); break;
case 4: buffer.appendText("WED"); break;
case 5: buffer.appendText("THU"); break;
case 6: buffer.appendText("FRI"); break;
case 7: buffer.appendText("SAT"); break;
default: buffer.appendText("UDF"); break;
}
}
else {
switch (wday) {
case 1: buffer.appendText("Sun"); break;
case 2: buffer.appendText("Mon"); break;
case 3: buffer.appendText("Tue"); break;
case 4: buffer.appendText("Wed"); break;
case 5: buffer.appendText("Thu"); break;
case 6: buffer.appendText("Fri"); break;
case 7: buffer.appendText("Sat"); break;
default: buffer.appendText("Udf"); break;
}
}
p += 1;
}
// DAY
else if (p + 2 < e && (p[1] == 'A' || p[1] == 'a') && (p[2] == 'Y' || p[2] == 'y')) {
if (p[2] == 'A') {
switch (wday) {
case 1: buffer.appendText("SUNDAY"); break;
case 2: buffer.appendText("MONDAY"); break;
case 3: buffer.appendText("TUESDAY"); break;
case 4: buffer.appendText("WEDNESDAY"); break;
case 5: buffer.appendText("THURSDAY"); break;
case 6: buffer.appendText("FRIDAY"); break;
case 7: buffer.appendText("SATURDAY"); break;
default: buffer.appendText("UNDEFINED"); break;
}
}
else {
switch (wday) {
case 1: buffer.appendText("Sunday"); break;
case 2: buffer.appendText("Monday"); break;
case 3: buffer.appendText("Tuesday"); break;
case 4: buffer.appendText("Wednesday"); break;
case 5: buffer.appendText("Thursday"); break;
case 6: buffer.appendText("Friday"); break;
case 7: buffer.appendText("Saturday"); break;
default: buffer.appendText("Undefined"); break;
}
}
p += 2;
}
// D
else {
buffer.appendInteger(wday);
}
continue;
}
// .............................................................................
// HH, HH12, HH24
// .............................................................................
if (p[0] == 'H' || p[0] == 'h') {
if (p + 1 < e && (p[1] == 'H' || p[1] == 'h')) {
// HH12
if (p + 3 < e && p[2] == '1' && p[3] == '2') {
buffer.appendInteger2(hour % 12);
p += 3;
}
// HH24
else if (p + 3 < e && p[2] == '2' && p[3] == '4') {
buffer.appendInteger2(hour);
p += 3;
}
// HH
else {
buffer.appendInteger2(hour);
p += 1;
}
continue;
}
}
// .............................................................................
// SS, SSSSS
// .............................................................................
if (p[0] == 'S' || p[0] == 's') {
if (p + 1 < e && (p[1] == 'S' || p[1] == 's')) {
// SSSSSS
if (p + 4 < e && (p[2] == 'S' || p[2] == 's') && (p[3] == 'S' || p[3] == 's') && (p[4] == 'S' || p[4] == 's')) {
buffer.appendInteger(hour * 3600 + minute * 60 + second);
p += 4;
}
// SS
else {
buffer.appendInteger2(second);
}
continue;
}
}
// .............................................................................
// something else
// .............................................................................
buffer.appendChar(*p);
}
string result = buffer.c_str();
return result;
}
// .............................................................................
// UTF8
// .............................................................................
// this function takes a sequence of hexadecimal characters (inputStr) of a particular
// length (len) and output 1,2,3 or 4 characters which represents the utf8 encoding
// of the unicode representation of that character.
bool unicodeToUTF8 (const char* inputStr, const size_t& len, string& outputStr) {
uint32_t outputInt = 0;
bool ok;
ok = parseHexanumber(inputStr, len, &outputInt);
if (ok == false) {
outputStr = string(inputStr, len);
return false;
}
ok = isHighSurrugate(outputInt) || isLowSurrugate(outputInt);
if (ok == true) {
outputStr.append("?");
return false;
}
ok = toUtf8(outputInt, outputStr);
if (ok == false) {
outputStr = string(inputStr, len);
}
return ok;
}
// .............................................................................
// UTF16
// .............................................................................
// this function converts unicode symbols whose code points lies in U+10000 to U+10FFFF
//
// the parameters of the function correspond to the UTF16 description for
// the code points mentioned above
//
// high_surrogate is the high surrogate bytes sequence, valid values begin with D[89AB]
// low_surrogate is the low surrogate bytes sequence, valid values begin with D[CDEF]
// for details see: http://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B10000_to_U.2B10FFFF
//
bool convertUTF16ToUTF8 (const char* high_surrogate, const char* low_surrogate, string& outputStr) {
uint32_t w1 = 0;
uint32_t w2 = 0;
uint32_t v;
bool ok = true;
ok = ok && parseHexanumber(high_surrogate, 4, &w1);
ok = ok && parseHexanumber(low_surrogate, 4, &w2);
if (ok == false) {
return false;
}
ok = isHighSurrugate(w1) && isLowSurrugate(w2);
ok = ok && toUnicode(w1, w2, &v);
if (ok == true) {
toUtf8(v, outputStr);
}
return ok;
}
// .............................................................................
// BASE64
// .............................................................................
string encodeBase64 (string const& in) {
unsigned char charArray3[3];
unsigned char charArray4[4];
string ret;
int i = 0;
unsigned char const* bytesToEncode = reinterpret_cast<unsigned char const*>(in.c_str());
size_t in_len = in.size();
while (in_len--) {
charArray3[i++] = *(bytesToEncode++);
if (i == 3) {
charArray4[0] = (charArray3[0] & 0xfc) >> 2;
charArray4[1] = ((charArray3[0] & 0x03) << 4) + ((charArray3[1] & 0xf0) >> 4);
charArray4[2] = ((charArray3[1] & 0x0f) << 2) + ((charArray3[2] & 0xc0) >> 6);
charArray4[3] = charArray3[2] & 0x3f;
for (i = 0; i < 4; i++) {
ret += BASE64_CHARS[charArray4[i]];
}
i = 0;
}
}
if (i != 0) {
for(int j = i; j < 3; j++) {
charArray3[j] = '\0';
}
charArray4[0] = (charArray3[0] & 0xfc) >> 2;
charArray4[1] = ((charArray3[0] & 0x03) << 4) + ((charArray3[1] & 0xf0) >> 4);
charArray4[2] = ((charArray3[1] & 0x0f) << 2) + ((charArray3[2] & 0xc0) >> 6);
charArray4[3] = charArray3[2] & 0x3f;
for (int j = 0; (j < i + 1); j++) {
ret += BASE64_CHARS[charArray4[j]];
}
while ((i++ < 3)) {
ret += '=';
}
}
return ret;
}
string decodeBase64 (string const& source) {
unsigned char charArray4[4];
unsigned char charArray3[3];
string ret;
int i = 0;
int inp = 0;
int in_len = (int) source.size();
while (in_len-- && (source[inp] != '=') && isBase64(source[inp])) {
charArray4[i++] = source[inp];
inp++;
if (i ==4) {
for (i = 0; i < 4; i++) {
charArray4[i] = BASE64_REVS[charArray4[i]];
}
charArray3[0] = (charArray4[0] << 2) + ((charArray4[1] & 0x30) >> 4);
charArray3[1] = ((charArray4[1] & 0xf) << 4) + ((charArray4[2] & 0x3c) >> 2);
charArray3[2] = ((charArray4[2] & 0x3) << 6) + charArray4[3];
for (i = 0; (i < 3); i++) {
ret += charArray3[i];
}
i = 0;
}
}
if (i) {
for (int j = i; j < 4; j++) {
charArray4[j] = 0;
}
for (int j = 0; j < 4; j++) {
charArray4[j] = BASE64_REVS[charArray4[j]];
}
charArray3[0] = (charArray4[0] << 2) + ((charArray4[1] & 0x30) >> 4);
charArray3[1] = ((charArray4[1] & 0xf) << 4) + ((charArray4[2] & 0x3c) >> 2);
charArray3[2] = ((charArray4[2] & 0x3) << 6) + charArray4[3];
for (int j = 0; j < i - 1; j++) {
ret += charArray3[j];
}
}
return ret;
}
string encodeBase64U (string const& in) {
unsigned char charArray3[3];
unsigned char charArray4[4];
string ret;
int i = 0;
unsigned char const* bytesToEncode = reinterpret_cast<unsigned char const*>(in.c_str());
size_t in_len = in.size();
while (in_len--) {
charArray3[i++] = *(bytesToEncode++);
if (i == 3) {
charArray4[0] = (charArray3[0] & 0xfc) >> 2;
charArray4[1] = ((charArray3[0] & 0x03) << 4) + ((charArray3[1] & 0xf0) >> 4);
charArray4[2] = ((charArray3[1] & 0x0f) << 2) + ((charArray3[2] & 0xc0) >> 6);
charArray4[3] = charArray3[2] & 0x3f;
for (i = 0; i < 4; i++) {
ret += BASE64U_CHARS[charArray4[i]];
}
i = 0;
}
}
if (i != 0) {
for(size_t j = i; j < 3; j++) {
charArray3[j] = '\0';
}
charArray4[0] = (charArray3[0] & 0xfc) >> 2;
charArray4[1] = ((charArray3[0] & 0x03) << 4) + ((charArray3[1] & 0xf0) >> 4);
charArray4[2] = ((charArray3[1] & 0x0f) << 2) + ((charArray3[2] & 0xc0) >> 6);
charArray4[3] = charArray3[2] & 0x3f;
for (int j = 0; (j < i + 1); j++) {
ret += BASE64U_CHARS[charArray4[j]];
}
while ((i++ < 3)) {
ret += '=';
}
}
return ret;
}
string decodeBase64U (string const& source) {
unsigned char charArray4[4];
unsigned char charArray3[3];
string ret;
int i = 0;
int inp = 0;
int in_len = (int) source.size();
while (in_len-- && (source[inp] != '=') && isBase64U(source[inp])) {
charArray4[i++] = source[inp];
inp++;
if (i ==4) {
for (i = 0; i < 4; i++) {
charArray4[i] = BASE64U_REVS[charArray4[i]];
}
charArray3[0] = (charArray4[0] << 2) + ((charArray4[1] & 0x30) >> 4);
charArray3[1] = ((charArray4[1] & 0xf) << 4) + ((charArray4[2] & 0x3c) >> 2);
charArray3[2] = ((charArray4[2] & 0x3) << 6) + charArray4[3];
for (i = 0; (i < 3); i++) {
ret += charArray3[i];
}
i = 0;
}
}
if (i) {
for (size_t j = i; j < 4; j++) {
charArray4[j] = 0;
}
for (size_t j = 0; j < 4; j++) {
charArray4[j] = BASE64U_REVS[charArray4[j]];
}
charArray3[0] = (charArray4[0] << 2) + ((charArray4[1] & 0x30) >> 4);
charArray3[1] = ((charArray4[1] & 0xf) << 4) + ((charArray4[2] & 0x3c) >> 2);
charArray3[2] = ((charArray4[2] & 0x3) << 6) + charArray4[3];
for (int j = 0; j < i - 1; j++) {
ret += charArray3[j];
}
}
return ret;
}
// .............................................................................
// ADDITIONAL STRING UTILITIES
// .............................................................................
string correctPath (const string& incorrectPath) {
#ifdef _WIN32
return replace (incorrectPath, "/", "\\");
#else
return replace (incorrectPath, "\\", "/");
#endif
}
// In a list str = "xx,yy,zz ...", entry(n,str,',') returns the nth entry of the list delimited
// by ','. E.g entry(2,str,',') = 'yy'
string entry (const size_t pos, string const& sourceStr, string const& delimiter) {
size_t delLength = delimiter.length();
size_t sourceLength = sourceStr.length();
if (pos == 0) {
return "";
}
if (delLength == 0 || sourceLength == 0) {
return sourceStr;
}
size_t k = 0;
size_t offSet = 0;
while (true) {
size_t delPos = sourceStr.find(delimiter, offSet);
if ((delPos == sourceStr.npos) || (delPos >= sourceLength) || (offSet >= sourceLength)) {
return sourceStr.substr(offSet);
}
++k;
if (k == pos) {
return sourceStr.substr(offSet, delPos - offSet);
}
offSet = delPos + delLength;
}
return sourceStr;
}
/// Determines the number of entries in a list str = "xx,yyy,zz,www".
/// numEntries(str,',') = 4.
size_t numEntries (string const& sourceStr, string const& delimiter) {
size_t delLength = delimiter.length();
size_t sourceLength = sourceStr.length();
if (sourceLength == 0) {
return (0);
}
if (delLength == 0) {
return (1);
}
size_t k = 1;
for (size_t j = 0; j < sourceLength; ++j) {
bool match = true;
for (size_t i = 0; i < delLength; ++i) {
if (sourceStr[j + i] != delimiter[i]) {
match = false;
break;
}
}
if (match) {
j += (delLength - 1);
++k;
continue;
}
}
return k;
}
string encodeHex (string const& str) {
char* tmp;
size_t len;
tmp = TRI_EncodeHexString(str.c_str(), str.length(), &len);
string result = string(tmp, len);
TRI_FreeString(TRI_CORE_MEM_ZONE, tmp);
return result;
}
string decodeHex (string const& str) {
char* tmp;
size_t len;
tmp = TRI_DecodeHexString(str.c_str(), str.length(), &len);
string result = string(tmp, len);
TRI_FreeString(TRI_CORE_MEM_ZONE, tmp);
return result;
}
}
}
}
// -----------------------------------------------------------------------------
// --SECTION-- END-OF-FILE
// -----------------------------------------------------------------------------
// Local Variables:
// mode: outline-minor
// outline-regexp: "/// @brief\\|/// {@inheritDoc}\\|/// @page\\|// --SECTION--\\|/// @\\}"
// End:
Reference in New Issue View Git Blame Copy Permalink