va_list lst;

va_start(lst, fmt);

std::string rv = stl_vsprintf(fmt, lst);

va_end(lst);

return rv;

/* Allow small (about single line) strings to be printed into stack memory

std::array<char,128> buf;

va_list args2;

va_copy(args2, args);

int rsz = vsnprintf(&buf[0], buf.size(), fmt, args2);

va_end(args2);

if (rsz < 0)

return std::string(); /* Error occurred */

if (static_cast<unsigned>(rsz) < buf.size())

return std::string(&buf[0], rsz); /* Whole string fits to a single line buffer */

std::string rv;

// Allocate enough memory for the output and null termination

rv.resize(rsz);

rsz = vsnprintf(&rv[0], rv.size()+1, fmt, args);

if (rsz < static_cast<int>(rv.size()))

rv.resize(std::max(rsz,0));

return rv;

const std::string &str, const std::string &separator, bool squash_empty)

{

out->clear();

size_t start = 0, pos;

if (!separator.empty())

{

while ((pos = str.find(separator,start)) != std::string::npos)

{

if (pos > start || !squash_empty)

out->push_back(str.substr(start, pos-start));

start = pos + separator.size();

}

}

if (start < str.size() || !squash_empty)

out->push_back(str.substr(start));

return out->size() > 1;

{

std::stringstream ss;

for (size_t i = 0; i < items.size(); i++)

{

if (i)

ss << separator;

ss << items[i];

}

return ss.str();

{

std::string rv(str.size(),' ');

for (unsigned i = 0; i < str.size(); ++i)

rv[i] = toupper(str[i]);

return rv;

{

std::string rv(str.size(),' ');

for (unsigned i = 0; i < str.size(); ++i)

rv[i] = tolower(str[i]);

return rv;

{

std::string result;

result.reserve(str.size());

for (char c : str)

{

const char *mapped = normalized_table[(uint8_t)c];

if (mapped == NULL)

result += tolower(c);

else

while (*mapped != '\0')

{

result += tolower(*mapped);

++mapped;

}

}

return result;

word_wrap_whitespace_mode mode)

{

if (line_length == 0)

line_length = SIZE_MAX;

std::string line;

size_t break_pos = 0;

bool ignore_whitespace = false;

for (auto &c : str)

{

if (c == '\n')

{

out->push_back(line);

line.clear();

break_pos = 0;

ignore_whitespace = (mode == WSMODE_TRIM_LEADING);

continue;

}

if (isspace(c))

{

if (ignore_whitespace || (mode == WSMODE_COLLAPSE_ALL && break_pos == line.length()))

continue;

line.push_back((mode == WSMODE_COLLAPSE_ALL) ? ' ' : c);

break_pos = line.length();

}

else

{

line.push_back(c);

ignore_whitespace = false;

}

if (line.length() > line_length)

{

if (break_pos > 0)

{

// Break before last space, and skip that space

out->push_back(line.substr(0, break_pos - 1));

}

else

{

// Single word is too long, just break it

out->push_back(line.substr(0, line_length));

break_pos = line_length;

}

line = line.substr(break_pos);

break_pos = 0;

ignore_whitespace = (mode == WSMODE_TRIM_LEADING);

}

}

if (line.length())

out->push_back(line);

return true;

{

size_t ksize = key.size();

size_t psize = prefix.size();

if (ksize < psize || memcmp(prefix.data(), key.data(), psize) != 0)

return false;

if (tail)

tail->clear();

if (ksize == psize)

return true;

if (psize == 0 || prefix[psize-1] == '/')

{

if (tail) *tail = key.substr(psize);

return true;

}

if (key[psize] == '/')

{

if (tail) *tail = key.substr(psize+1);

return true;

}

return false;

{

struct timeval tv;

gettimeofday(&tv, NULL);

uint64_t ret = tv.tv_usec;

// Convert from micro seconds (10^-6) to milliseconds (10^-3)

ret /= 1000;

// Adds the seconds (10^0) after converting them to milliseconds (10^-3)

ret += (tv.tv_sec * 1000);

return ret;

{

FILETIME ft;

LARGE_INTEGER li;

// Get the amount of 100 nano seconds intervals elapsed since January 1, 1601 (UTC)

// and copy it to a LARGE_INTEGER structure.

GetSystemTimeAsFileTime(&ft);

li.LowPart = ft.dwLowDateTime;

li.HighPart = ft.dwHighDateTime;

uint64_t ret = li.QuadPart;

// Convert from file time to UNIX epoch time.

ret -= 116444736000000000LL;

// From 100 nano seconds (10^-7) to 1 millisecond (10^-3) intervals

ret /= 10000;

return ret;

uint32_t type = utf8d[byte];

*codep = (*state != UTF8_ACCEPT) ?

(byte & 0x3fu) | (*codep << 6) :

(0xff >> type) & (byte);

*state = utf8d[256 + *state + type];

return *state;

if (c <= 0x7F)

{

out[0] = c;

return 1;

}

else if (c <= 0x7FF)

{

out[0] = (0xC0 | (c >> 6));

out[1] = (0x80 | (c & 0x3F));

return 2;

}

else /*if (c <= 0xFFFF)*/

{

out[0] = (0xE0 | (c >> 12));

out[1] = (0x80 | ((c >> 6) & 0x3F));

out[2] = (0x80 | (c & 0x3F));

return 3;

}

{

std::string out;

out.reserve(in.size());

uint8_t buf[4];

for (size_t i = 0; i < in.size(); i++)

{

int cnt = encode(buf, character_table[(uint8_t)in[i]]);

out.append(&buf[0], &buf[cnt]);

}

return out;

{

// Unicode to normal lookup table

static std::map<uint32_t, char> ctable;

if (ctable.empty())

{

for (uint16_t i = 0; i < 256; i++)

if (character_table[i] != i)

ctable[character_table[i]] = char(i);

}

// Actual conversion loop

size_t size = in.size();

std::string out(size, char(0));

uint32_t codepoint = 0;

uint32_t state = UTF8_ACCEPT, prev = UTF8_ACCEPT;

uint32_t pos = 0;

for (unsigned i = 0; i < size; prev = state, i++) {

switch (decode(&state, &codepoint, uint8_t(in[i]))) {

case UTF8_ACCEPT:

if (codepoint < 256 && character_table[codepoint] == codepoint) {

out[pos++] = char(codepoint);

} else {

char v = ctable[codepoint];

out[pos++] = v ? v : '?';

}

break;

case UTF8_REJECT:

out[pos++] = '?';

if (prev != UTF8_ACCEPT) --i;

state = UTF8_ACCEPT;

break;

}

}

if (pos != size)

out.resize(pos);

return out;