OU/CWE-ou-minkata
1
0
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-18 11:19:10 +00:00
Code Releases Activity

Merge pull request #420 from zrax/plFormat

Browse Source 
plFormat: a type-safe string formatter
This commit is contained in:
Adam Johnson
2014-05-20 20:49:29 -04:00
parent 69f1e2c511 933ae6ec17
commit c9c7350d36
21 changed files with 813 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Sources/Plasma/CoreLib/CMakeLists.txt
View File

@ -51,6 +51,7 @@ set(CoreLib_SOURCES
hsWide.cpp
pcSmallRect.cpp
plFileSystem.cpp
plFormat.cpp
plGeneric.cpp
plLoadMask.cpp
plProduct.cpp
@ -96,6 +97,7 @@ set(CoreLib_HEADERS
hsWindows.h
pcSmallRect.h
plFileSystem.h
plFormat.h
plGeneric.h
plLoadMask.h
plProduct.h

6
Sources/Plasma/CoreLib/HeadSpin.cpp
View File

@ -49,7 +49,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#pragma hdrstop
#include "hsTemplates.h"
#include "plString.h"
#include "plFormat.h"
///////////////////////////////////////////////////////////////////////////
@ -535,7 +535,7 @@ std::vector<plString> DisplaySystemVersion()
if ( osvi.dwMajorVersion <= 4 )
{
versionStrs.push_back(plString::Format("version %d.%d %s (Build %d)\n",
versionStrs.push_back(plFormat("version {}.{} {} (Build {})\n",
osvi.dwMajorVersion,
osvi.dwMinorVersion,
osvi.szCSDVersion,
@ -543,7 +543,7 @@ std::vector<plString> DisplaySystemVersion()
}
else
{
versionStrs.push_back(plString::Format("%s (Build %d)\n",
versionStrs.push_back(plFormat("{} (Build {})\n",
osvi.szCSDVersion,
osvi.dwBuildNumber & 0xFFFF));
}

6
Sources/Plasma/CoreLib/hsStream.cpp
View File

@ -204,8 +204,8 @@ plString hsStream::ReadSafeWStringLong()
uint32_t hsStream::WriteSafeString(const plString &string)
{
int len = string.GetSize();
hsAssert(len<0xf000, plString::Format("string len of %d is too long for WriteSafeString %s, use WriteSafeStringLong",
len, string.c_str()).c_str() );
hsAssert(len<0xf000, plFormat("string len of {} is too long for WriteSafeString {}, use WriteSafeStringLong",
len, string).c_str() );
WriteLE16(len | 0xf000);
if (len > 0)
@ -226,7 +226,7 @@ uint32_t hsStream::WriteSafeWString(const plString &string)
{
plStringBuffer<uint16_t> wbuff = string.ToUtf16();
uint32_t len = wbuff.GetSize();
hsAssert(len<0xf000, plString::Format("string len of %d is too long for WriteSafeWString, use WriteSafeWStringLong",
hsAssert(len<0xf000, plFormat("string len of {} is too long for WriteSafeWString, use WriteSafeWStringLong",
len).c_str() );
WriteLE16(len | 0xf000);

15
Sources/Plasma/CoreLib/plFileSystem.cpp
View File

@ -187,10 +187,8 @@ plFileName plFileName::Join(const plFileName &base, const plFileName &path)
char last = base.fName.CharAt(base.GetSize() - 1);
char first = path.fName.CharAt(0);
if (last != '/' && last != '\\') {
if (first != '/' && first != '\\') {
return plString::Format("%s" PATH_SEPARATOR_STR "%s",
base.fName.c_str(), path.fName.c_str());
}
if (first != '/' && first != '\\')
return plFormat("{}" PATH_SEPARATOR_STR "{}", base, path);
return base.fName + path.fName;
} else if (first != '/' && first != '\\') {
return base.fName + path.fName;
@ -199,6 +197,11 @@ plFileName plFileName::Join(const plFileName &base, const plFileName &path)
return base.fName + path.fName.Substr(1);
}
PL_FORMAT_IMPL(const plFileName &)
{
return PL_FORMAT_FORWARD(format, value.AsString());
}
/* plFileInfo */
plFileInfo::plFileInfo(const plFileName &filename)
@ -544,7 +547,7 @@ plString plFileSystem::ConvertFileSize(uint64_t size)
{
const char* labels[] = { "KiB", "MiB", "GiB", "TiB", "PiB", "EiB" };
if (size < 1024)
return plString::Format("%i B");
return plFormat("{} B", size);
uint64_t last_div = size;
for (size_t i = 0; i < arrsize(labels); ++i) {
@ -561,5 +564,5 @@ plString plFileSystem::ConvertFileSize(uint64_t size)
}
// this should never happen
return plString::Format("%i %s", last_div, labels[arrsize(labels) - 1]);
return plFormat("{} {}", last_div, labels[arrsize(labels) - 1]);
}

6
Sources/Plasma/CoreLib/plFileSystem.h
View File

@ -47,6 +47,8 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#include <cstdio>
#include <cstddef>
#include "plFormat.h"
#if HS_BUILD_FOR_WIN32
# define PATH_SEPARATOR '\\'
# define PATH_SEPARATOR_STR "\\"
@ -225,6 +227,10 @@ inline plFileName operator+(const char *left, const plFileName &right)
{ return left + right.AsString(); }
// Shortcut for use in plFormat
PL_FORMAT_TYPE(const plFileName &)
/** Structure to get information about a file by name.
* \sa plFileName
*/

492
Sources/Plasma/CoreLib/plFormat.cpp Normal file
View File

@ -0,0 +1,492 @@
/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "plFormat.h"
#include "HeadSpin.h"
#include <cstdlib>
#include <cstring>
#define BADCHAR_REPLACEMENT (0xFFFDul)
namespace plFormat_Private
{
static const char *_scanNextFormat(_IFormatDataObject &data)
{
hsAssert(data.fFormatStr, "Passed a null format string!");
const char *ptr = data.fFormatStr;
while (*ptr) {
if (*ptr == '{')
return ptr;
++ptr;
}
return ptr;
}
static void _fetchPrefixChunk(_IFormatDataObject &data)
{
do {
const char *next = _scanNextFormat(data);
if (*next && *(next + 1) == '{') {
// Escaped '{'
data.fOutput.push_back(plStringBuffer<char>(data.fFormatStr, 1 + next - data.fFormatStr));
data.fFormatStr = next + 2;
continue;
}
if (next != data.fFormatStr)
data.fOutput.push_back(plStringBuffer<char>(data.fFormatStr, next - data.fFormatStr));
data.fFormatStr = next;
} while (0);
}
FormatSpec _FetchNextFormat(_IFormatDataObject &data)
{
_fetchPrefixChunk(data);
hsAssert(*data.fFormatStr == '{', "Too many actual parameters for format string");
FormatSpec spec;
const char *ptr = data.fFormatStr;
for ( ;; ) {
++ptr;
switch (*ptr) {
case 0:
hsAssert(0, "Unterminated format specifier.");
abort();
case '}':
// Done with format spec
data.fFormatStr = ptr + 1;
return spec;
break;
case '<':
spec.fAlignment = kAlignLeft;
break;
case '>':
spec.fAlignment = kAlignRight;
break;
case '_':
spec.fPadChar = *(ptr + 1);
hsAssert(spec.fPadChar, "Unterminated format specifier");
++ptr;
break;
case 'x':
spec.fDigitClass = kDigitHex;
break;
case 'X':
spec.fDigitClass = kDigitHexUpper;
break;
case '+':
spec.fDigitClass = kDigitDecAlwaysSigned;
break;
case 'd':
if (spec.fDigitClass != kDigitDecAlwaysSigned)
spec.fDigitClass = kDigitDec;
break;
case 'o':
spec.fDigitClass = kDigitOct;
break;
case 'b':
spec.fDigitClass = kDigitBin;
break;
case 'c':
spec.fDigitClass = kDigitChar;
break;
case 'f':
spec.fFloatClass = kFloatFixed;
break;
case 'e':
spec.fFloatClass = kFloatExp;
break;
case 'E':
spec.fFloatClass = kFloatExpUpper;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
{
char *end = nullptr;
spec.fPrecisionLeft = strtol(ptr, &end, 10);
ptr = end - 1;
}
break;
case '.':
{
hsAssert(*(ptr + 1), "Unterminated format specifier");
char *end = nullptr;
spec.fPrecisionRight = strtol(ptr + 1, &end, 10);
ptr = end - 1;
}
break;
default:
hsAssert(0, "Unexpected character in format string");
break;
}
}
}
plString _IFormat(plFormat_Private::_IFormatDataObject &data)
{
_fetchPrefixChunk(data);
hsAssert(*data.fFormatStr == 0, "Not enough actual parameters for format string");
size_t outsize = 0;
for (const plStringBuffer<char> &buf : data.fOutput)
outsize += buf.GetSize();
plStringBuffer<char> outbuf;
char *out_ptr = outbuf.CreateWritableBuffer(outsize);
for (const plStringBuffer<char> &buf : data.fOutput) {
memcpy(out_ptr, buf.GetData(), buf.GetSize());
out_ptr += buf.GetSize();
}
*out_ptr = 0;
return outbuf;
}
}
template <typename _IType>
void _IFormatNumeric_Impl(char *output_end, _IType value, int radix, bool upperCase = false)
{
if (value == 0) {
*(output_end - 1) = '0';
return;
}
while (value)
{
int digit = (value % radix);
value /= radix;
--output_end;
if (digit < 10)
*output_end = '0' + digit;
else if (upperCase)
*output_end = 'A' + digit - 10;
else
*output_end = 'a' + digit - 10;
}
}
template <typename _IType>
static plStringBuffer<char> _formatNumeric(const plFormat_Private::FormatSpec &format,
_IType value, int radix, bool upperCase = false)
{
char pad = format.fPadChar ? format.fPadChar : ' ';
size_t max = 0;
_IType temp = value;
while (temp) {
++max;
temp /= radix;
}
if (max == 0)
max = 1;
plStringBuffer<char> buffer;
if (format.fPrecisionLeft > max) {
char *output = buffer.CreateWritableBuffer(format.fPrecisionLeft);
memset(output, pad, format.fPrecisionLeft);
if (format.fAlignment == plFormat_Private::kAlignLeft) {
_IFormatNumeric_Impl<_IType>(output + max, value, radix, upperCase);
} else {
_IFormatNumeric_Impl<_IType>(output + format.fPrecisionLeft,
value, radix, upperCase);
}
output[format.fPrecisionLeft] = 0;
} else {
char *output = buffer.CreateWritableBuffer(max);
_IFormatNumeric_Impl<_IType>(output + max, value, radix, upperCase);
output[max] = 0;
}
return buffer;
}
// Currently, only decimal formatting supports rendering negative numbers
template <typename _IType>
static plStringBuffer<char> _formatDecimal(const plFormat_Private::FormatSpec &format, _IType value)
{
char pad = format.fPadChar ? format.fPadChar : ' ';
_IType abs = (value < 0) ? -value : value;
size_t max = 0;
_IType temp = abs;
while (temp) {
++max;
temp /= 10;
}
if (max == 0)
max = 1;
if (value < 0 || format.fDigitClass == plFormat_Private::kDigitDecAlwaysSigned)
++max;
plStringBuffer<char> buffer;
char *output;
if (format.fPrecisionLeft > max) {
output = buffer.CreateWritableBuffer(format.fPrecisionLeft);
memset(output, pad, format.fPrecisionLeft);
if (format.fAlignment == plFormat_Private::kAlignLeft)
_IFormatNumeric_Impl<_IType>(output + max, abs, 10);
else
_IFormatNumeric_Impl<_IType>(output + format.fPrecisionLeft, abs, 10);
output[format.fPrecisionLeft] = 0;
} else {
output = buffer.CreateWritableBuffer(max);
_IFormatNumeric_Impl<_IType>(output + max, abs, 10);
output[max] = 0;
}
int signPos = format.fPrecisionLeft - static_cast<int>(max);
if (signPos < 0)
signPos = 0;
if (value < 0)
output[signPos] = '-';
else if (format.fDigitClass == plFormat_Private::kDigitDecAlwaysSigned)
output[signPos] = '+';
return buffer;
}
static plStringBuffer<char> _formatChar(const plFormat_Private::FormatSpec &format, int ch)
{
hsAssert(format.fPrecisionLeft == 0 && format.fPadChar == 0,
"Char formatting does not currently support padding");
// Don't need to nul-terminate this, since plStringBuffer's constructor fixes it
char utf8[4];
size_t max;
// Yanked from plString
if (ch > 0x10FFFF) {
hsAssert(0, "Unicode character out of range");
// Character out of range; Use U+FFFD instead for release builds
max = 3;
utf8[0] = 0xE0 | ((BADCHAR_REPLACEMENT >> 12) & 0x0F);
utf8[1] = 0x80 | ((BADCHAR_REPLACEMENT >> 6) & 0x3F);
utf8[2] = 0x80 | ((BADCHAR_REPLACEMENT ) & 0x3F);
} else if (ch > 0xFFFF) {
max = 4;
utf8[0] = 0xF0 | ((ch >> 18) & 0x07);
utf8[1] = 0x80 | ((ch >> 12) & 0x3F);
utf8[2] = 0x80 | ((ch >> 6) & 0x3F);
utf8[3] = 0x80 | ((ch ) & 0x3F);
} else if (ch > 0x7FF) {
max = 3;
utf8[0] = 0xE0 | ((ch >> 12) & 0x0F);
utf8[1] = 0x80 | ((ch >> 6) & 0x3F);
utf8[2] = 0x80 | ((ch ) & 0x3F);
} else if (ch > 0x7F) {
max = 2;
utf8[0] = 0xC0 | ((ch >> 6) & 0x1F);
utf8[1] = 0x80 | ((ch ) & 0x3F);
} else {
max = 1;
utf8[0] = (char)ch;
}
return plStringBuffer<char>(utf8, max);
}
#define _PL_FORMAT_IMPL_INT_TYPE(_stype, _utype) \
PL_FORMAT_IMPL(_stype) \
{ \
/* Note: The use of unsigned here is not a typo -- we only format decimal
values with a sign, so we can convert everything else to unsigned. */ \
switch (format.fDigitClass) { \
case plFormat_Private::kDigitBin: \
return _formatNumeric<_utype>(format, value, 2); \
case plFormat_Private::kDigitOct: \
return _formatNumeric<_utype>(format, value, 8); \
case plFormat_Private::kDigitHex: \
return _formatNumeric<_utype>(format, value, 16, false); \
case plFormat_Private::kDigitHexUpper: \
return _formatNumeric<_utype>(format, value, 16, true); \
case plFormat_Private::kDigitDec: \
case plFormat_Private::kDigitDecAlwaysSigned: \
case plFormat_Private::kDigitDefault: \
return _formatDecimal<_stype>(format, value); \
case plFormat_Private::kDigitChar: \
return _formatChar(format, value); \
} \
\
hsAssert(0, "Unexpected digit class"); \
return plStringBuffer<char>(); \
} \
\
PL_FORMAT_IMPL(_utype) \
{ \
switch (format.fDigitClass) { \
case plFormat_Private::kDigitBin: \
return _formatNumeric<_utype>(format, value, 2); \
case plFormat_Private::kDigitOct: \
return _formatNumeric<_utype>(format, value, 8); \
case plFormat_Private::kDigitHex: \
return _formatNumeric<_utype>(format, value, 16, false); \
case plFormat_Private::kDigitHexUpper: \
return _formatNumeric<_utype>(format, value, 16, true); \
case plFormat_Private::kDigitDec: \
case plFormat_Private::kDigitDecAlwaysSigned: \
case plFormat_Private::kDigitDefault: \
return _formatDecimal<_utype>(format, value); \
case plFormat_Private::kDigitChar: \
return _formatChar(format, value); \
} \
\
hsAssert(0, "Unexpected digit class"); \
return plStringBuffer<char>(); \
}
_PL_FORMAT_IMPL_INT_TYPE(signed char, unsigned char)
_PL_FORMAT_IMPL_INT_TYPE(short, unsigned short)
_PL_FORMAT_IMPL_INT_TYPE(int, unsigned)
_PL_FORMAT_IMPL_INT_TYPE(long, unsigned long)
_PL_FORMAT_IMPL_INT_TYPE(int64_t, uint64_t)
PL_FORMAT_IMPL(char)
{
/* Note: The use of unsigned here is not a typo -- we only format decimal
values with a sign, so we can convert everything else to unsigned. */
switch (format.fDigitClass) {
case plFormat_Private::kDigitBin:
return _formatNumeric<unsigned char>(format, value, 2);
case plFormat_Private::kDigitOct:
return _formatNumeric<unsigned char>(format, value, 8);
case plFormat_Private::kDigitHex:
return _formatNumeric<unsigned char>(format, value, 16, false);
case plFormat_Private::kDigitHexUpper:
return _formatNumeric<unsigned char>(format, value, 16, true);
case plFormat_Private::kDigitDec:
case plFormat_Private::kDigitDecAlwaysSigned:
return _formatDecimal<signed char>(format, value);
case plFormat_Private::kDigitChar:
case plFormat_Private::kDigitDefault:
return _formatChar(format, value);
}
hsAssert(0, "Unexpected digit class");
return plStringBuffer<char>();
}
PL_FORMAT_IMPL(wchar_t)
{
switch (format.fDigitClass) {
case plFormat_Private::kDigitBin:
return _formatNumeric<wchar_t>(format, value, 2);
case plFormat_Private::kDigitOct:
return _formatNumeric<wchar_t>(format, value, 8);
case plFormat_Private::kDigitHex:
return _formatNumeric<wchar_t>(format, value, 16, false);
case plFormat_Private::kDigitHexUpper:
return _formatNumeric<wchar_t>(format, value, 16, true);
case plFormat_Private::kDigitDec:
case plFormat_Private::kDigitDecAlwaysSigned:
return _formatDecimal<wchar_t>(format, value);
case plFormat_Private::kDigitChar:
case plFormat_Private::kDigitDefault:
return _formatChar(format, value);
}
hsAssert(0, "Unexpected digit class");
return plStringBuffer<char>();
}
static plStringBuffer<char> _formatString(const plFormat_Private::FormatSpec &format,
const plStringBuffer<char> &value)
{
char pad = format.fPadChar ? format.fPadChar : ' ';
if (format.fPrecisionLeft > value.GetSize()) {
plStringBuffer<char> buf;
char *output = buf.CreateWritableBuffer(format.fPrecisionLeft);
memset(output, pad, format.fPrecisionLeft);
if (format.fAlignment == plFormat_Private::kAlignRight) {
memcpy(output + (format.fPrecisionLeft - value.GetSize()),
value.GetData(), value.GetSize());
} else {
memcpy(output, value.GetData(), value.GetSize());
}
output[format.fPrecisionLeft] = 0;
return buf;
}
return value;
}
PL_FORMAT_IMPL(const char *)
{
return _formatString(format, plString(value).ToUtf8());
}
PL_FORMAT_IMPL(const wchar_t *)
{
return _formatString(format, plString::FromWchar(value).ToUtf8());
}
PL_FORMAT_IMPL(const plString &)
{
return _formatString(format, value.ToUtf8());
}
PL_FORMAT_IMPL(const std::string &)
{
return _formatString(format, plStringBuffer<char>(value.c_str(), value.size()));
}
PL_FORMAT_IMPL(const std::wstring &)
{
return _formatString(format, plString::FromWchar(value.c_str(), value.size()).ToUtf8());
}
PL_FORMAT_IMPL(bool)
{
return PL_FORMAT_FORWARD(format, value ? "true" : "false");
}

227
Sources/Plasma/CoreLib/plFormat.h Normal file
View File

@ -0,0 +1,227 @@
/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#ifndef plFormat_Defined
#define plFormat_Defined
#include "plString.h"
#include <list>
#include <string>
#ifdef BUILDING_DOXYGEN // Doxygen doesn't appear to support variadic templates yet
/** Format a string using type-safe arguments
* \param format The format string -- see below for details
*
* Character Sequence | Description
* ------------------ | -----------
* `{}` | Format a value (using defaults)
* `{{` | Escape for a single '{' char
* `{options}` | Format a value, with the specified options (see below)
*
* Formatting Options
* ------------------
*
* Format Option | Description
* ------------- | -----------
* `<` | Align left
* `>` | Align right
* `NNN` | Pad to NNN characters (minimum - can be more)
* `+` | Show a '+' char for positive signed values (decimal only)
* `_C` | Use C as the pad character (only '\001'..'\177' supported for now)
* `x` | Hex (lower-case)
* `X` | Hex (upper-case)
* `o` | Octal
* `b` | Binary
* `d` | Decimal (default) -- when used with char types, outputs a number instead of the UTF representation of the char
* `c` | UTF character (default for character types)
* `FFF.EEE` | Use FFF.EEE floating point precision
* `f` | Fixed floating point format (ddd.ddd)
* `e` | Exponent notation for floating point (d.ddde[+/-]dd)
* `E` | Same as 'e' format, but with upper case E (d.dddE[+/-]dd)
*/
plString plFormat(const char *format, ...);
#endif
namespace plFormat_Private
{
enum Alignment : unsigned char
{
kAlignDefault, /**< Left for strings, right for numbers */
kAlignLeft, /**< Left alignment */
kAlignRight /**< Right alignment */
};
enum DigitClass : unsigned char
{
kDigitDefault, /**< Default digit formatting */
kDigitDec, /**< Format as decimal integer */
kDigitDecAlwaysSigned, /**< Same as `kDigitDec`, but include a '+' for positive numbers too */
kDigitHex, /**< Hex integer (assume unsigned) */
kDigitHexUpper, /**< Hex integer with upper-case digits */
kDigitOct, /**< Octal integer (assume unsigned) */
kDigitBin, /**< Binary integer (assume unsigned) */
kDigitChar /**< Single unicode character (as UTF-8) */
};
enum FloatClass : unsigned char
{
kFloatDefault, /**< Use Fixed or Exp format depending on value */
kFloatFixed, /**< Use Fixed notation (ddd.ddd) */
kFloatExp, /**< Use Exp notation (d.ddde[+/-]dd) */
kFloatExpUpper /**< Same as `kFloatExp`, but with an upper-case E */
};
/** Represents a parsed format tag, for use in formatter implementations. */
struct FormatSpec
{
int fPrecisionLeft = 0; /**< Requested padding and/or precision */
int fPrecisionRight = 0; /**< Requested precision after the . for floating-point */
char fPadChar = 0; /**< Explicit padding char (default is space) */
Alignment fAlignment = kAlignDefault; /**< Requested pad alignment */
DigitClass fDigitClass = kDigitDefault; /**< Requested int formatting */
FloatClass fFloatClass = kFloatDefault; /**< Requested float formatting */
};
// These need to be publically visible for the macros below, but shouldn't
// be used directly outside of plFormat and its macros
struct _IFormatDataObject
{
const char *fFormatStr;
std::list<plStringBuffer<char>> fOutput;
};
extern FormatSpec _FetchNextFormat(_IFormatDataObject &data);
}
/** Declare a formattable type for `plFormat`.
* \sa PL_FORMAT_IMPL()
*/
#define PL_FORMAT_TYPE(_type) \
extern plStringBuffer<char> _impl_plFormat_DataHandler( \
const plFormat_Private::FormatSpec &format, _type value); \
namespace plFormat_Private \
{ \
template <typename... _Args> \
plString _IFormat(_IFormatDataObject &data, _type value, _Args... args) \
{ \
plFormat_Private::FormatSpec format = plFormat_Private::_FetchNextFormat(data); \
data.fOutput.push_back(_impl_plFormat_DataHandler(format, value)); \
return _IFormat(data, args...); \
} \
} \
template <typename... _Args> \
plString plFormat(const char *fmt_str, _type value, _Args... args) \
{ \
plFormat_Private::_IFormatDataObject data; \
data.fFormatStr = fmt_str; \
plFormat_Private::FormatSpec format = plFormat_Private::_FetchNextFormat(data); \
data.fOutput.push_back(_impl_plFormat_DataHandler(format, value)); \
return plFormat_Private::_IFormat(data, args...); \
}
/** Provide the implementation for a formattable type for `plFormat`.
* \sa PL_FORMAT_TYPE(), PL_FORMAT_FORWARD()
*
* Example:
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* PL_FORMAT_IMPL(const MyType &)
* {
* return plFormat("MyType[data={},count={}]", value.data, value.count);
* }
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
#define PL_FORMAT_IMPL(_type) \
plStringBuffer<char> _impl_plFormat_DataHandler( \
const plFormat_Private::FormatSpec &format, _type value)
/** Shortcut to call another `PL_FORMAT_IMPL` formatter.
* \sa PL_FORMAT_IMPL()
*
* Example:
*
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* PL_FORMAT_IMPL(const MyType &)
* {
* return PL_FORMAT_FORWARD(format, value.ToString());
* }
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*/
#define PL_FORMAT_FORWARD(format, fwd_value) \
_impl_plFormat_DataHandler((format), (fwd_value))
PL_FORMAT_TYPE(char)
PL_FORMAT_TYPE(wchar_t)
PL_FORMAT_TYPE(signed char)
PL_FORMAT_TYPE(unsigned char)
PL_FORMAT_TYPE(short)
PL_FORMAT_TYPE(unsigned short)
PL_FORMAT_TYPE(int)
PL_FORMAT_TYPE(unsigned)
PL_FORMAT_TYPE(long)
PL_FORMAT_TYPE(unsigned long)
PL_FORMAT_TYPE(int64_t)
PL_FORMAT_TYPE(uint64_t)
PL_FORMAT_TYPE(const char *)
PL_FORMAT_TYPE(const wchar_t *)
PL_FORMAT_TYPE(const plString &)
// TODO: Remove these when they're no longer needed
PL_FORMAT_TYPE(const std::string &)
PL_FORMAT_TYPE(const std::wstring &)
// TODO: Implement floating point types (float, double). They're harder
// than the others, so I'll get around to them later >.>
// Formats as "true" or "false", following normal string formatting rules.
// To use other formats, don't pass us a bool directly...
PL_FORMAT_TYPE(bool)
namespace plFormat_Private
{
// End of the chain -- emits the last piece (if any) and builds the final string
plString _IFormat(_IFormatDataObject &data);
}
#endif // plFormat_Defined

8
Sources/Plasma/CoreLib/plProduct.cpp
View File

@ -44,7 +44,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#pragma hdrstop
#include "plProduct.h"
#include "plString.h"
#include "plFormat.h"
static_assert(PRODUCT_BUILD_ID > 0, "Build ID cannot be zero");
static_assert(PRODUCT_BUILD_TYPE > 0, "Build Type cannot be zero");
@ -89,8 +89,8 @@ const char *plProduct::UUID() { return PRODUCT_UUID; }
plString plProduct::ProductString()
{
static plString _cache = plString::Format(
"%s.%u.%u - " RELEASE_ACCESS "." RELEASE_TYPE,
CoreName().c_str(), BranchId(), BuildId());
static plString _cache = plFormat(
"{}.{}.{} - " RELEASE_ACCESS "." RELEASE_TYPE,
CoreName(), BranchId(), BuildId());
return _cache;
}

5
Sources/Plasma/CoreLib/plString.cpp
View File

@ -47,6 +47,7 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
#pragma hdrstop
#include "plString.h"
#include "plFormat.h"
#include <regex>
const plString plString::Null;
@ -609,7 +610,7 @@ bool plString::REMatch(const char *pattern, CaseSensitivity sense) const
if (std::regex_match(c_str(), re))
return true;
} catch (const std::regex_error& e) {
hsAssert(0, plString::Format("Regex match error: %s", e.what()).c_str());
hsAssert(0, plFormat("Regex match error: {}", e.what()).c_str());
}
return false;
@ -633,7 +634,7 @@ std::vector<plString> plString::RESearch(const char *pattern,
for (size_t i = 0; i < matches.size(); ++i)
substrings[i] = matches[i].str().c_str();
} catch (const std::regex_error& e) {
hsAssert(0, plString::Format("Regex search error: %s", e.what()).c_str());
hsAssert(0, plFormat("Regex search error: {}", e.what()).c_str());
}
return substrings;