Util.cpp File Reference

#include "Util.h"
#include "Common.h"
#include "Containers.h"
#include "IpAddress.h"
#include "StringConvert.h"
#include "Tokenize.h"
#include <algorithm>
#include <boost/core/demangle.hpp>
#include <cctype>
#include <cstdarg>
#include <sstream>
#include <string>
#include <utf8.h>

Go to the source code of this file.

Functions
void	stripLineInvisibleChars (std::string &str)
std::string	secsToTimeString (uint64 timeInSecs, bool shortText)
Optional< int32 >	MoneyStringToMoney (std::string_view moneyString)
uint32	TimeStringToSecs (const std::string &timestring)
bool	IsIPAddress (char const *ipaddress)
	Check if the string is a valid ip address representation. More...
uint32	CreatePIDFile (std::string const &filename)
	create PID file More...
uint32	GetPID ()
std::size_t	utf8length (std::string &utf8str)
void	utf8truncate (std::string &utf8str, std::size_t len)
bool	Utf8toWStr (char const *utf8str, std::size_t csize, wchar_t *wstr, std::size_t &wsize)
bool	Utf8toWStr (std::string_view utf8str, std::wstring &wstr)
bool	WStrToUtf8 (wchar_t const *wstr, std::size_t size, std::string &utf8str)
bool	WStrToUtf8 (std::wstring_view wstr, std::string &utf8str)
void	wstrToUpper (std::wstring &str)
void	wstrToLower (std::wstring &str)
void	strToUpper (std::string &str)
void	strToLower (std::string &str)
std::wstring	GetMainPartOfName (std::wstring const &wname, uint32_t declension)
bool	utf8ToConsole (std::string_view utf8str, std::string &conStr)
bool	consoleToUtf8 (std::string_view conStr, std::string &utf8str)
bool	Utf8FitTo (std::string_view str, std::wstring_view search)
void	utf8printf (FILE *out, const char *str,...)
void	vutf8printf (FILE *out, const char *str, va_list *ap)
bool	Utf8ToUpperOnlyLatin (std::string &utf8String)
bool	StringEqualI (std::string_view a, std::string_view b)
bool	StringContainsStringI (std::string_view haystack, std::string_view needle)
bool	StringCompareLessI (std::string_view a, std::string_view b)
std::string	GetTypeName (std::type_info const &info)

Function Documentation

consoleToUtf8()

bool consoleToUtf8	(	std::string_view	conStr,
		std::string &	utf8str
	)

{
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
    std::wstring wstr;
    wstr.resize(conStr.size());
    OemToCharBuffW(&conStr[0], &wstr[0], uint32(conStr.size()));
 
    return WStrToUtf8(wstr, utf8str);
#else
    // not implemented yet
    utf8str = conStr;
    return true;
#endif
}

References WStrToUtf8().

Referenced by Acore::ACLogSink< T >::write().

CreatePIDFile()

uint32 CreatePIDFile

(

std::string const &

filename

)

create PID file

{
    FILE* pid_file = fopen(filename.c_str(), "w");
    if (!pid_file)
    {
        return 0;
    }
 
    uint32 pid = GetPID();
 
    fprintf(pid_file, "%u", pid);
    fclose(pid_file);
 
    return pid;
}

References GetPID().

Referenced by main().

GetMainPartOfName()

std::wstring GetMainPartOfName	(	std::wstring const &	wname,
		uint32_t	declension
	)

{
    // supported only Cyrillic cases
    if (wname.empty() || !isCyrillicCharacter(wname[0]) || declension > 5)
    {
        return wname;
    }
 
    // Important: end length must be <= MAX_INTERNAL_PLAYER_NAME-MAX_PLAYER_NAME (3 currently)
    static std::wstring const a_End    = L"\u0430";
    static std::wstring const o_End    = L"\u043E";
    static std::wstring const ya_End   = L"\u044F";
    static std::wstring const ie_End   = L"\u0435";
    static std::wstring const i_End    = L"\u0438";
    static std::wstring const yeru_End = L"\u044B";
    static std::wstring const u_End    = L"\u0443";
    static std::wstring const yu_End   = L"\u044E";
    static std::wstring const oj_End   = L"\u043E\u0439";
    static std::wstring const ie_j_End = L"\u0435\u0439";
    static std::wstring const io_j_End = L"\u0451\u0439";
    static std::wstring const o_m_End  = L"\u043E\u043C";
    static std::wstring const io_m_End = L"\u0451\u043C";
    static std::wstring const ie_m_End = L"\u0435\u043C";
    static std::wstring const soft_End = L"\u044C";
    static std::wstring const j_End    = L"\u0439";
 
    static std::array<std::array<std::wstring const*, 7>, 6> const dropEnds = {{
            { &a_End,  &o_End,    &ya_End,   &ie_End,  &soft_End, &j_End,    nullptr },
            { &a_End,  &ya_End,   &yeru_End, &i_End,   nullptr,   nullptr,   nullptr },
            { &ie_End, &u_End,    &yu_End,   &i_End,   nullptr,   nullptr,   nullptr },
            { &u_End,  &yu_End,   &o_End,    &ie_End,  &soft_End, &ya_End,   &a_End  },
            { &oj_End, &io_j_End, &ie_j_End, &o_m_End, &io_m_End, &ie_m_End, &yu_End },
            { &ie_End, &i_End,    nullptr,   nullptr,  nullptr,   nullptr,   nullptr }
        }
    };
 
    std::size_t const thisLen = wname.length();
    std::array<std::wstring const*, 7> const& endings = dropEnds[declension];
    for (const std::wstring* endingPtr : endings)
    {
        if (endingPtr == nullptr)
        {
            break;
        }
 
        std::wstring const& ending = *endingPtr;
        std::size_t const endLen = ending.length();
        if (endLen > thisLen)
        {
            continue;
        }
 
        if (wname.compare(thisLen - endLen, endLen, ending) == 0)
        {
            return wname.substr(0, thisLen - endLen);
        }
    }
 
    return wname;
}

References isCyrillicCharacter().

Referenced by ObjectMgr::CheckDeclinedNames().

GetPID()

uint32 GetPID

(

)

{
#ifdef _WIN32
    DWORD pid = GetCurrentProcessId();
#else
    pid_t pid = getpid();
#endif
 
    return uint32(pid);
}

Referenced by CreatePIDFile().

GetTypeName()

std::string GetTypeName

(

std::type_info const &

info

)

{
    return boost::core::demangle(info.name());
}

IsIPAddress()

bool IsIPAddress

(

char const *

ipaddress

)

Check if the string is a valid ip address representation.

{
    if (!ipaddress)
    {
        return false;
    }
 
    boost::system::error_code error;
    Acore::Net::make_address(ipaddress, error);
    return !error;
}

Referenced by ban_commandscript::HandleBanHelper(), ban_commandscript::HandleBanInfoIPCommand(), and ban_commandscript::HandleUnBanHelper().

MoneyStringToMoney()

Optional< int32 > MoneyStringToMoney

(

std::string_view

moneyString

)

{
    int32 money = 0;
 
    bool hadG = false;
    bool hadS = false;
    bool hadC = false;
 
    for (std::string_view token : Acore::Tokenize(moneyString, ' ', false))
    {
        uint32 unit;
        switch (token[token.length() - 1])
        {
        case 'g':
            if (hadG)
            {
                return std::nullopt;
            }
            hadG = true;
            unit = 100 * 100;
            break;
        case 's':
            if (hadS)
            {
                return std::nullopt;
            }
            hadS = true;
            unit = 100;
            break;
        case 'c':
            if (hadC)
            {
                return std::nullopt;
            }
            hadC = true;
            unit = 1;
            break;
        default:
            return std::nullopt;
        }
 
        Optional<uint32> amount = Acore::StringTo<uint32>(token.substr(0, token.length() - 1));
        if (amount)
        {
            money += (unit * *amount);
        }
        else
        {
            return std::nullopt;
        }
    }
 
    return money;
}

References Acore::Tokenize().

Referenced by modify_commandscript::HandleModifyMoneyCommand().

secsToTimeString()

std::string secsToTimeString	(	uint64	timeInSecs,
		bool	shortText
	)

{
    uint64 secs    = timeInSecs % MINUTE;
    uint64 minutes = timeInSecs % HOUR / MINUTE;
    uint64 hours   = timeInSecs % DAY  / HOUR;
    uint64 days    = timeInSecs / DAY;
 
    std::ostringstream ss;
    if (days)
    {
        ss << days << (shortText ? "d" : " day(s) ");
    }
    if (hours)
    {
        ss << hours << (shortText ? "h" : " hour(s) ");
    }
    if (minutes)
    {
        ss << minutes << (shortText ? "m" : " minute(s) ");
    }
    if (secs || (!days && !hours && !minutes))
    {
        ss << secs << (shortText ? "s" : " second(s) ");
    }
 
    std::string str = ss.str();
 
    if (!shortText && !str.empty() && str[str.size() - 1] == ' ')
    {
        str.resize(str.size() - 1);
    }
 
    return str;
}

References DAY, HOUR, and MINUTE.

Referenced by BanMgr::BanAccount(), BanMgr::BanAccountByPlayerName(), BanMgr::BanCharacter(), BanMgr::BanIP(), GmTicket::FormatMessageString(), ban_commandscript::HandleBanCharacterCommand(), ban_commandscript::HandleBanHelper(), ban_commandscript::HandleBanInfoCharacterCommand(), ban_commandscript::HandleBanInfoHelper(), ban_commandscript::HandleBanInfoIPCommand(), deserter_commandscript::HandleDeserterAdd(), deserter_commandscript::HandleDeserterRemove(), deserter_commandscript::HandleDeserterRemoveAll(), event_commandscript::HandleEventInfoCommand(), gobject_commandscript::HandleGameObjectTargetCommand(), instance_commandscript::HandleInstanceListBindsCommand(), instance_commandscript::HandleInstanceUnbindCommand(), WorldSession::HandleMessagechatOpcode(), misc_commandscript::HandleMuteCommand(), npc_commandscript::HandleNpcInfoCommand(), npc_commandscript::HandleNpcSetSpawnTimeCommand(), misc_commandscript::HandlePInfoCommand(), server_commandscript::HandleServerInfoCommand(), WorldSession::HandleTextEmoteOpcode(), main(), GmTicket::SetChatLog(), and World::ShutdownMsg().

StringCompareLessI()

bool StringCompareLessI	(	std::string_view	a,
		std::string_view	b
	)

{
    return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end(), [](char c1, char c2) { return std::tolower(c1) < std::tolower(c2); });
}

Referenced by StringCompareLessI_T::operator()().

StringContainsStringI()

bool StringContainsStringI	(	std::string_view	haystack,
		std::string_view	needle
	)

{
    return haystack.end() !=
        std::search(haystack.begin(), haystack.end(), needle.begin(), needle.end(), [](char c1, char c2) { return std::tolower(c1) == std::tolower(c2); });
}

Referenced by arena_commandscript::HandleArenaLookupCommand(), and ValueContainsStringI().

StringEqualI()

bool StringEqualI	(	std::string_view	a,
		std::string_view	b
	)

{
    return std::equal(a.begin(), a.end(), b.begin(), b.end(), [](char c1, char c2) { return std::tolower(c1) == std::tolower(c2); });
}

Referenced by Acore::Impl::StringConvertImpl::For< T, std::enable_if_t< std::is_integral_v< T > &&!std::is_same_v< T, bool > > >::FromString(), Acore::Impl::StringConvertImpl::For< bool, void >::FromString(), Acore::Impl::StringConvertImpl::For< T, std::enable_if_t< std::is_floating_point_v< T > > >::FromString(), Acore::Impl::ChatCommands::ChatCommandNode::GetAutoCompletionsFor(), Field::GetData(), GuildMgr::GetGuildByName(), misc_commandscript::HandleLinkGraveCommand(), modify_commandscript::HandleModifyGenderCommand(), misc_commandscript::HandleNearGraveCommand(), anonymous_namespace{Field.cpp}::IsCorrectAlias(), Acore::Impl::ChatCommands::ArgInfo< T, std::enable_if_t< std::is_enum_v< T > > >::Match(), Acore::Impl::ChatCommands::ChatCommandNode::SendCommandHelpFor(), StringStartsWithI(), Acore::ChatCommands::ExactSequence< chars >::TryConsume(), and Acore::Impl::ChatCommands::ChatCommandNode::TryExecuteCommand().

stripLineInvisibleChars()

void stripLineInvisibleChars

(

std::string &

str

)

{
    static std::string const invChars = " \t\7\n";
 
    std::size_t wpos = 0;
 
    bool space = false;
    for (std::size_t pos = 0; pos < str.size(); ++pos)
    {
        if (invChars.find(str[pos]) != std::string::npos)
        {
            if (!space)
            {
                str[wpos++] = ' ';
                space = true;
            }
        }
        else
        {
            if (wpos != pos)
            {
                str[wpos++] = str[pos];
            }
            else
            {
                ++wpos;
            }
            space = false;
        }
    }
 
    if (wpos < str.size())
    {
        str.erase(wpos, str.size());
    }
    if (str.find("|TInterface") != std::string::npos)
    {
        str.clear();
    }
}

strToLower()

void strToLower

(

std::string &

str

)

{ std::transform(std::begin(str), std::end(str), std::begin(str), charToLower); }

References charToLower().

Referenced by ExtractGameobjectModels().

strToUpper()

void strToUpper

(

std::string &

str

)

{ std::transform(std::begin(str), std::end(str), std::begin(str), charToUpper); }

References charToUpper().

TimeStringToSecs()

uint32 TimeStringToSecs

(

const std::string &

timestring

)

{
    uint32 secs       = 0;
    uint32 buffer     = 0;
    uint32 multiplier = 0;
 
    for (std::string::const_iterator itr = timestring.begin(); itr != timestring.end(); ++itr)
    {
        if (isdigit(*itr))
        {
            buffer *= 10;
            buffer += (*itr) - '0';
        }
        else
        {
            switch (*itr)
            {
                case 'd':
                    multiplier = DAY;
                    break;
                case 'h':
                    multiplier = HOUR;
                    break;
                case 'm':
                    multiplier = MINUTE;
                    break;
                case 's':
                    multiplier = 1;
                    break;
                default :
                    return 0;                         //bad format
            }
            buffer *= multiplier;
            secs += buffer;
            buffer = 0;
        }
    }
 
    return secs;
}

References DAY, HOUR, and MINUTE.

Referenced by BanMgr::BanAccount(), BanMgr::BanAccountByPlayerName(), BanMgr::BanCharacter(), BanMgr::BanIP(), ban_commandscript::HandleBanCharacterCommand(), ban_commandscript::HandleBanHelper(), bf_commandscript::HandleBattlefieldTimer(), deserter_commandscript::HandleDeserterAdd(), deserter_commandscript::HandleDeserterRemoveAll(), misc_commandscript::HandleMuteCommand(), npc_commandscript::HandleNpcSetSpawnTimeCommand(), server_commandscript::HandleServerIdleRestartCommand(), server_commandscript::HandleServerIdleShutDownCommand(), server_commandscript::HandleServerRestartCommand(), and server_commandscript::HandleServerShutDownCommand().

Utf8FitTo()

bool Utf8FitTo	(	std::string_view	str,
		std::wstring_view	search
	)

{
    std::wstring temp;
 
    if (!Utf8toWStr(str, temp))
    {
        return false;
    }
 
    // converting to lower case
    wstrToLower(temp);
 
    if (temp.find(search) == std::wstring::npos)
    {
        return false;
    }
 
    return true;
}

References Utf8toWStr(), and wstrToLower().

Referenced by AuctionHouseObject::BuildListAuctionItems(), learn_commandscript::HandleLearnAllRecipesCommand(), lookup_commandscript::HandleLookupAreaCommand(), lookup_commandscript::HandleLookupCreatureCommand(), lookup_commandscript::HandleLookupEventCommand(), lookup_commandscript::HandleLookupFactionCommand(), lookup_commandscript::HandleLookupItemCommand(), lookup_commandscript::HandleLookupItemSetCommand(), lookup_commandscript::HandleLookupMapCommand(), lookup_commandscript::HandleLookupObjectCommand(), lookup_commandscript::HandleLookupQuestCommand(), lookup_commandscript::HandleLookupSkillCommand(), lookup_commandscript::HandleLookupSpellCommand(), lookup_commandscript::HandleLookupTaxiNodeCommand(), lookup_commandscript::HandleLookupTitleCommand(), WorldSession::HandleWhoOpcode(), and list_commandscript::ShouldListAura().

utf8length()

std::size_t utf8length

(

std::string &

utf8str

)

{
    try
    {
        return utf8::distance(utf8str.c_str(), utf8str.c_str() + utf8str.size());
    }
    catch (std::exception const&)
    {
        utf8str.clear();
        return 0;
    }
}

Referenced by AccountMgr::ChangeEmail(), AccountMgr::ChangePassword(), AccountMgr::ChangeUsername(), and AccountMgr::CreateAccount().

utf8printf()

void utf8printf	(	FILE *	out,
		const char *	str,
			...
	)

{
    va_list ap;
    va_start(ap, str);
    vutf8printf(out, str, &ap);
    va_end(ap);
}

References vutf8printf().

Referenced by AppenderConsole::_write().

utf8ToConsole()

bool utf8ToConsole	(	std::string_view	utf8str,
		std::string &	conStr
	)

{
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
    std::wstring wstr;
    if (!Utf8toWStr(utf8str, wstr))
    {
        return false;
    }
 
    conStr.resize(wstr.size());
    CharToOemBuffW(&wstr[0], &conStr[0], wstr.size());
#else
    // not implemented yet
    conStr = utf8str;
#endif
 
    return true;
}

References Utf8toWStr().

Utf8ToUpperOnlyLatin()

bool Utf8ToUpperOnlyLatin

(

std::string &

utf8String

)

{
    std::wstring wstr;
    if (!Utf8toWStr(utf8String, wstr))
    {
        return false;
    }
 
    std::transform(wstr.begin(), wstr.end(), wstr.begin(), wcharToUpperOnlyLatin);
 
    return WStrToUtf8(wstr, utf8String);
}

References Utf8toWStr(), wcharToUpperOnlyLatin(), and WStrToUtf8().

Referenced by AccountMgr::ChangeEmail(), AccountMgr::ChangePassword(), AccountMgr::ChangeUsername(), RASession::CheckAccessLevel(), RASession::CheckPassword(), AccountMgr::CheckPassword(), AccountMgr::CreateAccount(), account_commandscript::HandleAccountDeleteCommand(), account_commandscript::HandleAccountRemoveLockCountryCommand(), account_commandscript::HandleAccountSet2FACommand(), account_commandscript::HandleAccountSetAddonCommand(), account_commandscript::HandleAccountSetEmailCommand(), account_commandscript::HandleAccountSetGmLevelCommand(), account_commandscript::HandleAccountSetPasswordCommand(), ban_commandscript::HandleBanHelper(), ban_commandscript::HandleBanInfoAccountCommand(), lookup_commandscript::HandleLookupPlayerAccountCommand(), misc_commandscript::HandleMuteInfoCommand(), ban_commandscript::HandleUnBanHelper(), PlayerDump::InitializeTables(), AccountInfo::LoadResult(), StringsEqualCaseInsensitive(), and Acore::ChatCommands::AccountIdentifier::TryConsume().

Utf8toWStr() [1/2]

bool Utf8toWStr	(	char const *	utf8str,
		std::size_t	csize,
		wchar_t *	wstr,
		std::size_t &	wsize
	)

{
    try
    {
        Acore::CheckedBufferOutputIterator<wchar_t> out(wstr, wsize);
        out = utf8::utf8to16(utf8str, utf8str + csize, out);
        wsize -= out.remaining(); // remaining unused space
        wstr[wsize] = L'\0';
    }
    catch (std::exception const&)
    {
        // Replace the converted string with an error message if there is enough space
        // Otherwise just return an empty string
        const wchar_t* errorMessage = L"An error occurred converting string from UTF-8 to WStr";
        std::size_t errorMessageLength = std::char_traits<wchar_t>::length(errorMessage);
        if (wsize >= errorMessageLength)
        {
            std::wcscpy(wstr, errorMessage);
            wsize = std::char_traits<wchar_t>::length(wstr);
        }
        else if (wsize > 0)
        {
            wstr[0] = L'\0';
            wsize = 0;
        }
        else
        {
            wsize = 0;
        }
 
        return false;
    }
 
    return true;
}

References Acore::CheckedBufferOutputIterator< T >::remaining().

Referenced by ObjectMgr::AddGameTele(), ObjectMgr::AddProfanityPlayerName(), ObjectMgr::AddReservedPlayerName(), ObjectMgr::CheckDeclinedNames(), ObjectMgr::CheckPetName(), ObjectMgr::CheckPlayerName(), ObjectMgr::DeleteGameTele(), AuctionListItemsDelayEvent::Execute(), ChannelMgr::GetChannel(), ObjectMgr::GetGameTele(), Graveyard::GetGraveyard(), ChannelMgr::GetJoinChannel(), go_commandscript::HandleGoXYZCommand(), lookup_commandscript::HandleLookupAreaCommand(), lookup_commandscript::HandleLookupCreatureCommand(), lookup_commandscript::HandleLookupEventCommand(), lookup_commandscript::HandleLookupFactionCommand(), lookup_commandscript::HandleLookupItemCommand(), lookup_commandscript::HandleLookupItemSetCommand(), lookup_commandscript::HandleLookupMapCommand(), lookup_commandscript::HandleLookupObjectCommand(), lookup_commandscript::HandleLookupQuestCommand(), lookup_commandscript::HandleLookupSkillCommand(), lookup_commandscript::HandleLookupSpellCommand(), lookup_commandscript::HandleLookupTaxiNodeCommand(), lookup_commandscript::HandleLookupTeleCommand(), lookup_commandscript::HandleLookupTitleCommand(), modify_commandscript::HandleModifyRepCommand(), WorldSession::HandlePetRename(), server_commandscript::HandleServerIdleRestartCommand(), server_commandscript::HandleServerIdleShutDownCommand(), server_commandscript::HandleServerRestartCommand(), server_commandscript::HandleServerSetMotdCommand(), server_commandscript::HandleServerShutDownCommand(), WorldSession::HandleSetPlayerDeclinedNames(), WorldSession::HandleWhoOpcode(), ObjectMgr::IsProfanityName(), ObjectMgr::IsReservedName(), ObjectMgr::IsValidChannelName(), ObjectMgr::IsValidCharterName(), ChannelMgr::LoadChannels(), ObjectMgr::LoadGameTele(), Graveyard::LoadGraveyardFromDB(), ObjectMgr::LoadProfanityNamesFromDB(), ObjectMgr::LoadProfanityNamesFromDBC(), ObjectMgr::LoadReservedPlayerNamesDB(), ObjectMgr::LoadReservedPlayerNamesDBC(), normalizePlayerName(), Acore::ChatCommands::WTail::TryConsume(), Acore::Impl::ChatCommands::ArgInfo< std::wstring, void >::TryConsume(), WhoListCacheMgr::Update(), Utf8FitTo(), utf8ToConsole(), Utf8ToUpperOnlyLatin(), and vutf8printf().

Utf8toWStr() [2/2]

bool Utf8toWStr	(	std::string_view	utf8str,
		std::wstring &	wstr
	)

{
    wstr.clear();
    try
    {
        utf8::utf8to16(utf8str.begin(), utf8str.end(), std::back_inserter(wstr));
    }
    catch (std::exception const&)
    {
        wstr.clear();
        return false;
    }
 
    return true;
}

Referenced by Utf8toWStr().

utf8truncate()

void utf8truncate	(	std::string &	utf8str,
		std::size_t	len
	)

{
    try
    {
        std::size_t wlen = utf8::distance(utf8str.c_str(), utf8str.c_str() + utf8str.size());
        if (wlen <= len)
        {
            return;
        }
 
        std::wstring wstr;
        wstr.resize(wlen);
        utf8::utf8to16(utf8str.c_str(), utf8str.c_str() + utf8str.size(), &wstr[0]);
        wstr.resize(len);
        char* oend = utf8::utf16to8(wstr.c_str(), wstr.c_str() + wstr.size(), &utf8str[0]);
        utf8str.resize(oend - (&utf8str[0]));               // remove unused tail
    }
    catch (std::exception const&)
    {
        utf8str.clear();
    }
}

Referenced by PlayerSocial::SetFriendNote(), and Guild::BankTab::SetText().

vutf8printf()

void vutf8printf	(	FILE *	out,
		const char *	str,
		va_list *	ap
	)

{
#if AC_PLATFORM == AC_PLATFORM_WINDOWS
    char temp_buf[32 * 1024];
    wchar_t wtemp_buf[32 * 1024];
 
    std::size_t temp_len = vsnprintf(temp_buf, 32 * 1024, str, *ap);
    //vsnprintf returns -1 if the buffer is too small
    if (temp_len == std::size_t(-1))
    {
        temp_len = 32 * 1024 - 1;
    }
 
    std::size_t wtemp_len = 32 * 1024 - 1;
    Utf8toWStr(temp_buf, temp_len, wtemp_buf, wtemp_len);
 
    CharToOemBuffW(&wtemp_buf[0], &temp_buf[0], uint32(wtemp_len + 1));
    fprintf(out, "%s", temp_buf);
#else
    vfprintf(out, str, *ap);
#endif
}

References Utf8toWStr().

Referenced by utf8printf().

wstrToLower()

void wstrToLower

(

std::wstring &

str

)

{ std::transform(std::begin(str), std::end(str), std::begin(str), wcharToLower); }

References wcharToLower().

Referenced by ObjectMgr::AddGameTele(), ObjectMgr::AddProfanityPlayerName(), ObjectMgr::AddReservedPlayerName(), ObjectMgr::CheckPlayerName(), ObjectMgr::DeleteGameTele(), AuctionListItemsDelayEvent::Execute(), ChannelMgr::GetChannel(), ObjectMgr::GetGameTele(), Graveyard::GetGraveyard(), ChannelMgr::GetJoinChannel(), learn_commandscript::HandleLearnAllRecipesCommand(), lookup_commandscript::HandleLookupAreaCommand(), lookup_commandscript::HandleLookupCreatureCommand(), lookup_commandscript::HandleLookupEventCommand(), lookup_commandscript::HandleLookupFactionCommand(), lookup_commandscript::HandleLookupItemCommand(), lookup_commandscript::HandleLookupItemSetCommand(), lookup_commandscript::HandleLookupMapCommand(), lookup_commandscript::HandleLookupObjectCommand(), lookup_commandscript::HandleLookupQuestCommand(), lookup_commandscript::HandleLookupSkillCommand(), lookup_commandscript::HandleLookupSpellCommand(), lookup_commandscript::HandleLookupTaxiNodeCommand(), lookup_commandscript::HandleLookupTeleCommand(), lookup_commandscript::HandleLookupTitleCommand(), modify_commandscript::HandleModifyRepCommand(), WorldSession::HandleWhoOpcode(), ObjectMgr::IsProfanityName(), ObjectMgr::IsReservedName(), list_commandscript::ListAurasCommand(), ObjectMgr::LoadGameTele(), Graveyard::LoadGraveyardFromDB(), ObjectMgr::LoadProfanityNamesFromDB(), ObjectMgr::LoadReservedPlayerNamesDB(), normalizePlayerName(), WhoListCacheMgr::Update(), and Utf8FitTo().

wstrToUpper()

void wstrToUpper

(

std::wstring &

str

)

{ std::transform(std::begin(str), std::end(str), std::begin(str), wcharToUpper); }

References wcharToUpper().

WStrToUtf8() [1/2]

bool WStrToUtf8	(	std::wstring_view	wstr,
		std::string &	utf8str
	)

{
    try
    {
        std::string utf8str2;
        utf8str2.resize(wstr.size() * 4);                     // allocate for most long case
 
        if (!wstr.empty())
        {
            char* oend = utf8::utf16to8(wstr.begin(), wstr.end(), &utf8str2[0]);
            utf8str2.resize(oend - (&utf8str2[0]));                // remove unused tail
        }
 
        utf8str = utf8str2;
    }
    catch (std::exception const&)
    {
        utf8str.clear();
        return false;
    }
 
    return true;
}

WStrToUtf8() [2/2]

bool WStrToUtf8	(	wchar_t const *	wstr,
		std::size_t	size,
		std::string &	utf8str
	)

{
    try
    {
        std::string utf8str2;
        utf8str2.resize(size * 4);                            // allocate for most long case
 
        if (size)
        {
            char* oend = utf8::utf16to8(wstr, wstr + size, &utf8str2[0]);
            utf8str2.resize(oend - (&utf8str2[0]));               // remove unused tail
        }
 
        utf8str = utf8str2;
    }
    catch (std::exception const&)
    {
        utf8str.clear();
        return false;
    }
 
    return true;
}

Referenced by CliThread(), consoleToUtf8(), server_commandscript::HandleServerIdleRestartCommand(), server_commandscript::HandleServerIdleShutDownCommand(), server_commandscript::HandleServerRestartCommand(), server_commandscript::HandleServerSetMotdCommand(), server_commandscript::HandleServerShutDownCommand(), normalizePlayerName(), and Utf8ToUpperOnlyLatin().