Util.h File Reference

#include "Containers.h"
#include "Define.h"
#include "Errors.h"
#include "Optional.h"
#include <algorithm>
#include <array>
#include <cctype>
#include <list>
#include <map>
#include <string>
#include <vector>

Go to the source code of this file.

Classes
struct	Finder< T, S >
struct	StringCompareLessI_T
class	HookList< T >
class	flag96

Namespaces
namespace	Acore
namespace	Acore::Impl

Enumerations
enum	ComparisionType {   COMP_TYPE_EQ = 0 ,   COMP_TYPE_HIGH ,   COMP_TYPE_LOW ,   COMP_TYPE_HIGH_EQ ,   COMP_TYPE_LOW_EQ ,   COMP_TYPE_MAX }

Functions
void	stripLineInvisibleChars (std::string &src)
AC_COMMON_API Optional< int32 >	MoneyStringToMoney (std::string_view moneyString)
std::string	secsToTimeString (uint64 timeInSecs, bool shortText=false)
uint32	TimeStringToSecs (const std::string &timestring)
void	ApplyPercentModFloatVar (float &var, float val, bool apply)
template<class T , class U >
T	CalculatePct (T base, U pct)
template<class T , class U >
T	AddPct (T &base, U pct)
template<class T , class U >
T	ApplyPct (T &base, U pct)
template<class T >
T	RoundToInterval (T &num, T floor, T ceil)
AC_COMMON_API bool	Utf8toWStr (std::string_view utf8str, std::wstring &wstr)
AC_COMMON_API bool	Utf8toWStr (char const *utf8str, size_t csize, wchar_t *wstr, size_t &wsize)
bool	Utf8toWStr (std::string_view utf8str, wchar_t *wstr, size_t &wsize)
AC_COMMON_API bool	WStrToUtf8 (std::wstring_view wstr, std::string &utf8str)
AC_COMMON_API bool	WStrToUtf8 (wchar_t const *wstr, size_t size, std::string &utf8str)
size_t	utf8length (std::string &utf8str)
void	utf8truncate (std::string &utf8str, size_t len)
bool	isBasicLatinCharacter (wchar_t wchar)
bool	isExtendedLatinCharacter (wchar_t wchar)
bool	isCyrillicCharacter (wchar_t wchar)
bool	isEastAsianCharacter (wchar_t wchar)
bool	isNumeric (wchar_t wchar)
bool	isNumeric (char c)
bool	IsEvenNumber (int32 n)
bool	isNumeric (char const *str)
bool	isNumericOrSpace (wchar_t wchar)
bool	isBasicLatinString (std::wstring_view wstr, bool numericOrSpace)
bool	isExtendedLatinString (std::wstring_view wstr, bool numericOrSpace)
bool	isCyrillicString (std::wstring_view wstr, bool numericOrSpace)
bool	isEastAsianString (std::wstring_view wstr, bool numericOrSpace)
char	charToUpper (char c)
char	charToLower (char c)
wchar_t	wcharToUpper (wchar_t wchar)
wchar_t	wcharToUpperOnlyLatin (wchar_t wchar)
wchar_t	wcharToLower (wchar_t wchar)
void	wstrToUpper (std::wstring &str)
void	wstrToLower (std::wstring &str)
std::wstring	GetMainPartOfName (std::wstring const &wname, uint32 declension)
AC_COMMON_API bool	utf8ToConsole (std::string_view utf8str, std::string &conStr)
AC_COMMON_API bool	consoleToUtf8 (std::string_view conStr, std::string &utf8str)
AC_COMMON_API bool	Utf8FitTo (std::string_view str, std::wstring_view search)
AC_COMMON_API void	utf8printf (FILE *out, const char *str,...)
AC_COMMON_API void	vutf8printf (FILE *out, const char *str, va_list *ap)
AC_COMMON_API bool	Utf8ToUpperOnlyLatin (std::string &utf8String)
bool	IsIPAddress (char const *ipaddress)
	Check if the string is a valid ip address representation.
uint32	CreatePIDFile (const std::string &filename)
	create PID file
uint32	GetPID ()
AC_COMMON_API std::string	Acore::Impl::ByteArrayToHexStr (uint8 const *bytes, size_t length, bool reverse=false)
AC_COMMON_API void	Acore::Impl::HexStrToByteArray (std::string_view str, uint8 *out, size_t outlen, bool reverse=false)
template<typename Container >
std::string	ByteArrayToHexStr (Container const &c, bool reverse=false)
template<size_t Size>
void	HexStrToByteArray (std::string_view str, std::array< uint8, Size > &buf, bool reverse=false)
template<size_t Size>
std::array< uint8, Size >	HexStrToByteArray (std::string_view str, bool reverse=false)
AC_COMMON_API bool	StringEqualI (std::string_view str1, std::string_view str2)
bool	StringStartsWith (std::string_view haystack, std::string_view needle)
bool	StringStartsWithI (std::string_view haystack, std::string_view needle)
AC_COMMON_API bool	StringContainsStringI (std::string_view haystack, std::string_view needle)
template<typename T >
bool	ValueContainsStringI (std::pair< T, std::string_view > const &haystack, std::string_view needle)
AC_COMMON_API bool	StringCompareLessI (std::string_view a, std::string_view b)
template<class T >
bool	CompareValues (ComparisionType type, T val1, T val2)
template<typename E >
constexpr std::underlying_type< E >::type	AsUnderlyingType (E enumValue)
template<typename Ret , typename T1 , typename... T>
Ret *	Coalesce (T1 *first, T *... rest)
AC_COMMON_API std::string	GetTypeName (std::type_info const &)
template<typename T >
std::string	GetTypeName ()
template<typename T >
std::enable_if_t<!std::is_same_v< std::decay_t< T >, std::type_info >, std::string >	GetTypeName (T &&v)

Enumeration Type Documentation

ComparisionType

enum ComparisionType

Enumerator
COMP_TYPE_EQ
COMP_TYPE_HIGH
COMP_TYPE_LOW
COMP_TYPE_HIGH_EQ
COMP_TYPE_LOW_EQ
COMP_TYPE_MAX

{
    COMP_TYPE_EQ = 0,
    COMP_TYPE_HIGH,
    COMP_TYPE_LOW,
    COMP_TYPE_HIGH_EQ,
    COMP_TYPE_LOW_EQ,
    COMP_TYPE_MAX
};

Function Documentation

AddPct()

template<class T , class U >

T AddPct ( T &  base, U  pct  )

inline

{
    return base += CalculatePct(base, pct);
}

References CalculatePct().

Referenced by KillRewarder::_RewardXP(), HostileReference::addThreatPercent(), Unit::CalcAbsorbResist(), Unit::CalcArmorReducedDamage(), spell_gen_reduced_above_60_aura::CalculateAmount(), spell_hun_cower::CalculateAmount(), spell_pri_lightwell_renew::CalculateAmount(), spell_pal_sacred_shield_base::CalculateAmount(), spell_sha_earth_shield::CalculateAmount(), spell_warr_rend::CalculateAmount(), AuraEffect::CalculateAmount(), spell_dru_treant_scaling::CalculateAPAmount(), spell_hun_generic_scaling::CalculateAPAmount(), Unit::CalculateLevelPenalty(), Unit::CalculateMeleeDamage(), spell_hun_generic_scaling::CalculateSPAmount(), CalculateSpellAmount(), Unit::CalculateSpellDamageTaken(), spell_dk_pet_scaling::CalculateStatAmount(), spell_hun_generic_scaling::CalculateStatAmount(), Spell::Delayed(), Spell::DelayedChannel(), Spell::EffectEnergize(), Spell::EffectSchoolDMG(), Spell::EffectWeaponDmg(), Player::getMaxTimer(), Unit::GetTotalAuraMultiplier(), Unit::GetTotalAuraMultiplierByAffectMask(), Unit::GetTotalAuraMultiplierByMiscMask(), Unit::GetTotalAuraMultiplierByMiscValue(), spell_pri_shadow_word_death::HandleDamage(), spell_sha_healing_stream_totem::HandleDummy(), spell_dk_raise_ally::HandleDummy(), spell_dk_death_strike::HandleDummy(), spell_dk_scourge_strike::HandleDummy(), spell_sha_lava_lash::HandleDummy(), spell_warl_life_tap::HandleDummy(), Unit::HandleDummyAuraProc(), spell_pri_prayer_of_mending_heal::HandleHeal(), AuraEffect::HandlePeriodicHealAurasTick(), spell_hun_ascpect_of_the_viper::HandleProc(), spell_pal_sacred_shield_base::HandleProc(), Unit::MeleeDamageBonusDone(), Unit::MeleeDamageBonusTaken(), Unit::ModSpellDuration(), spell_warl_siphon_life::OnProc(), Unit::processDummyAuras(), spell_dk_death_and_decay::RecalculateDamage(), spell_gen_reduced_above_60::RecalculateDamage(), Creature::Regenerate(), Player::Regenerate(), Creature::RegenerateHealth(), Player::RegenerateHealth(), Player::RewardHonor(), Player::RewardQuest(), Unit::RewardRage(), Battleground::RewardReputationToTeam(), Unit::SpellCriticalDamageBonus(), Unit::SpellDamageBonusDone(), Unit::SpellDamageBonusTaken(), Unit::SpellHealingBonusDone(), Unit::SpellHealingBonusTaken(), Unit::SpellPctDamageModsDone(), Unit::SpellPctHealingModsDone(), and Unit::UpdateSpeed().

ApplyPct()

template<class T , class U >

T ApplyPct ( T &  base, U  pct  )

inline

{
    return base = CalculatePct(base, pct);
}

References CalculatePct().

Referenced by spell_sha_earth_shield::CalculateAmount(), Spell::EffectDestroyAllTotems(), Spell::EffectSchoolDMG(), Spell::EffectWeaponDmg(), spell_warr_bloodthirst::HandleDamage(), spell_warl_life_tap::HandleDummy(), spell_warr_deep_wounds::HandleDummy(), Unit::HandleDummyAuraProc(), AuraEffect::HandlePeriodicManaLeechAuraTick(), spell_hun_glyph_of_arcane_shot::HandleProc(), spell_hun_chimera_shot::HandleScriptEffect(), Unit::MeleeDamageBonusTaken(), Player::RegenerateHealth(), and Unit::SpellDamageBonusTaken().

ApplyPercentModFloatVar()

void ApplyPercentModFloatVar ( float &  var, float  val, bool  apply  )

inline

{
    if (val == -100.0f)     // prevent set var to zero
    {
        val = -99.99f;
    }
    var *= (apply ? (100.0f + val) / 100.0f : 100.0f / (100.0f + val));
}

Referenced by Unit::ApplyAttackTimePercentMod(), Object::ApplyPercentModFloatValue(), Player::HandleBaseModValue(), AuraEffect::HandleModThreat(), Unit::HandleStatModifier(), and Unit::ModifyPowerPct().

AsUnderlyingType()

template<typename E >

constexpr std::underlying_type< E >::type AsUnderlyingType ( E  enumValue )

constexpr

{
    static_assert(std::is_enum<E>::value, "AsUnderlyingType can only be used with enums");
    return static_cast<typename std::underlying_type<E>::type>(enumValue);
}

Referenced by SmartAIMgr::IsEventValid(), ObjectMgr::LoadCreatureAddons(), ObjectMgr::LoadCreatureTemplateAddons(), WorldObject::SetVisibilityDistanceOverride(), and CreatureMovementData::ToString().

ByteArrayToHexStr()

template<typename Container >

std::string ByteArrayToHexStr	(	Container const &	c,
		bool	reverse = false
	)

{
    return Acore::Impl::ByteArrayToHexStr(std::data(c), std::size(c), reverse);
}

References Acore::Impl::ByteArrayToHexStr().

Referenced by WardenMac::Init(), WardenWin::Init(), and UpdateFetcher::Update().

CalculatePct()

template<class T , class U >

T CalculatePct ( T  base, U  pct  )

inline

{
    return T(base * static_cast<float>(pct) / 100.0f);
}

Referenced by spell_shield_generator::spell_shield_generator_AuraScript::Absorb(), spell_charge_shield_bomber::spell_charge_shield_bomber_AuraScript::Absorb(), spell_dk_anti_magic_shell_raid::Absorb(), spell_dk_anti_magic_shell_self::Absorb(), spell_dk_anti_magic_zone::Absorb(), spell_dk_spell_deflection::Absorb(), spell_dk_will_of_the_necropolis::Absorb(), spell_dru_moonkin_form_passive::Absorb(), spell_dru_primal_tenacity::Absorb(), spell_rog_nerves_of_steel::Absorb(), spell_sha_astral_shift::Absorb(), spell_dru_savage_defense::Absorb(), spell_pal_ardent_defender::Absorb(), AddPct(), ApplyPct(), Player::ApplySpellMod(), Unit::CalcAbsorbResist(), Unit::CalcArmorReducedDamage(), SpellInfo::CalcPowerCost(), spell_mark_of_kazzak::spell_mark_of_kazzak_AuraScript::CalculateAmount(), spell_dru_owlkin_frenzy::CalculateAmount(), spell_dru_rip::CalculateAmount(), spell_dru_innervate::CalculateAmount(), spell_gen_lifeblood::CalculateAmount(), spell_pal_sacred_shield_base::CalculateAmount(), spell_warl_demonic_knowledge::CalculateAmount(), spell_dru_treant_scaling::CalculateAPAmount(), spell_hun_generic_scaling::CalculateAPAmount(), spell_pri_shadowfiend_scaling::CalculateAPAmount(), spell_sha_feral_spirit_scaling::CalculateAPAmount(), spell_sha_fire_elemental_scaling::CalculateAPAmount(), spell_warl_generic_scaling::CalculateAPAmount(), spell_warl_infernal_scaling::CalculateAPAmount(), Player::CalculateReputationGain(), spell_dru_treant_scaling::CalculateResistanceAmount(), spell_hun_generic_scaling::CalculateResistanceAmount(), spell_mage_pet_scaling::CalculateResistanceAmount(), spell_pri_shadowfiend_scaling::CalculateResistanceAmount(), spell_sha_feral_spirit_scaling::CalculateResistanceAmount(), spell_sha_fire_elemental_scaling::CalculateResistanceAmount(), spell_warl_generic_scaling::CalculateResistanceAmount(), spell_warl_infernal_scaling::CalculateResistanceAmount(), spell_dk_pet_scaling::CalculateSPAmount(), spell_dru_treant_scaling::CalculateSPAmount(), spell_hun_generic_scaling::CalculateSPAmount(), spell_mage_pet_scaling::CalculateSPAmount(), spell_pri_shadowfiend_scaling::CalculateSPAmount(), spell_sha_feral_spirit_scaling::CalculateSPAmount(), spell_sha_fire_elemental_scaling::CalculateSPAmount(), spell_warl_generic_scaling::CalculateSPAmount(), spell_warl_infernal_scaling::CalculateSPAmount(), CalculateSpellAmount(), spell_dk_pet_scaling::CalculateStatAmount(), spell_dru_treant_scaling::CalculateStatAmount(), spell_hun_generic_scaling::CalculateStatAmount(), spell_mage_pet_scaling::CalculateStatAmount(), spell_pri_shadowfiend_scaling::CalculateStatAmount(), spell_sha_feral_spirit_scaling::CalculateStatAmount(), spell_sha_fire_elemental_scaling::CalculateStatAmount(), spell_warl_generic_scaling::CalculateStatAmount(), spell_warl_infernal_scaling::CalculateStatAmount(), Unit::CountPctFromCurHealth(), Unit::CountPctFromMaxHealth(), Unit::DealDamage(), Spell::DelayedChannel(), ThreatMgr::DoAddThreat(), Spell::EffectDestroyAllTotems(), Spell::EffectEnergize(), Spell::EffectEnergizePct(), Spell::EffectPowerBurn(), Spell::EffectResurrect(), Spell::EffectSchoolDMG(), Spell::EffectSelfResurrect(), AuctionEntry::GetAuctionCut(), AuctionHouseMgr::GetAuctionDeposit(), AuctionEntry::GetAuctionOutBid(), Unit::GetCombatRatingDamageReduction(), spell_mt_phoenix_burn::spell_mt_phoenix_burn_SpellScript::HandleAfterCast(), spell_illidari_council_empyreal_balance::spell_illidari_council_empyreal_balance_SpellScript::HandleAfterCast(), spell_sha_totem_of_wrath::HandleAfterCast(), spell_warl_haunt::HandleAfterHit(), AuraEffect::HandleAuraModIncreaseHealthPercent(), Unit::HandleAuraProc(), Aura::HandleAuraSpecificMods(), spell_dru_lifebloom::HandleDispel(), spell_dk_raise_ally::HandleDummy(), spell_sha_mana_tide_totem::HandleDummy(), spell_warr_concussion_blow::HandleDummy(), Unit::HandleDummyAuraProc(), AuraEffect::HandleModPowerCostPCT(), AuraEffect::HandlePeriodicManaLeechAuraTick(), spell_mage_ignite::HandleProc(), spell_hun_ascpect_of_the_viper::HandleProc(), spell_yogg_saron_grim_reprisal::spell_yogg_saron_grim_reprisal_AuraScript::HandleProc(), spell_dru_t10_balance_4p_bonus::HandleProc(), spell_dru_living_seed::HandleProc(), spell_item_blessing_of_ancient_kings::HandleProc(), spell_item_necrotic_touch::HandleProc(), spell_mage_burnout::HandleProc(), spell_mage_master_of_elements::HandleProc(), spell_pri_divine_aegis::HandleProc(), spell_pri_glyph_of_prayer_of_healing::HandleProc(), spell_sha_t10_restoration_4p_bonus::HandleProc(), spell_sha_item_mana_surge::HandleProc(), spell_warl_drain_soul::HandleProc(), Unit::HandleProcTriggerSpell(), spell_hun_chimera_shot::HandleScriptEffect(), boss_curator::JustEngagedWith(), spell_valanar_kinetic_bomb_absorb::spell_valanar_kinetic_bomb_absorb_AuraScript::OnAbsorb(), spell_blood_queen_essence_of_the_blood_queen::spell_blood_queen_essence_of_the_blood_queen_AuraScript::OnProc(), spell_pal_eye_for_an_eye::OnProc(), spell_warl_siphon_life::OnProc(), spell_warl_fel_synergy::OnProc(), spell_warr_damage_shield::OnProc(), spell_item_oracle_ablutions::PrepareSpellScript(), spell_pilgrims_bounty_food_aura::RecalculateHook(), Unit::RecalculateObjectScale(), spell_pri_power_word_shield_aura::ReflectDamage(), OPvPCapturePoint::SetCapturePointData(), Unit::SpellBaseDamageBonusDone(), Unit::SpellBaseHealingBonusDone(), spell_dk_anti_magic_shell_self::Trigger(), spell_mage_incanters_absorbtion_base_AuraScript::Trigger(), Player::UpdateArmor(), Player::UpdateAttackPowerAndDamage(), Player::UpdateManaRegen(), and Player::UpdateRating().

charToLower()

char charToLower ( char  c )

inline

{ return std::tolower(c); }

Referenced by strToLower().

charToUpper()

char charToUpper ( char  c )

inline

{ return std::toupper(c); }

Referenced by strToUpper().

Coalesce()

template<typename Ret , typename T1 , typename... T>

Ret * Coalesce	(	T1 *	first,
		T *...	rest
	)

{
    if constexpr (sizeof...(T) > 0)
        return (first ? static_cast<Ret*>(first) : Coalesce<Ret>(rest...));
    else
        return static_cast<Ret*>(first);
}

CompareValues()

template<class T >

bool CompareValues	(	ComparisionType	type,
		T	val1,
		T	val2
	)

{
    switch (type)
    {
        case COMP_TYPE_EQ:
            return val1 == val2;
        case COMP_TYPE_HIGH:
            return val1 > val2;
        case COMP_TYPE_LOW:
            return val1 < val2;
        case COMP_TYPE_HIGH_EQ:
            return val1 >= val2;
        case COMP_TYPE_LOW_EQ:
            return val1 <= val2;
        default:
            // incorrect parameter
            ABORT();
            return false;
    }
}

References ABORT, COMP_TYPE_EQ, COMP_TYPE_HIGH, COMP_TYPE_HIGH_EQ, COMP_TYPE_LOW, and COMP_TYPE_LOW_EQ.

Referenced by Condition::Meets(), and AchievementCriteriaData::Meets().

consoleToUtf8()

AC_COMMON_API 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

(

const std::string &

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	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    = { wchar_t(0x0430), wchar_t(0x0000) };
    static std::wstring const o_End    = { wchar_t(0x043E), wchar_t(0x0000) };
    static std::wstring const ya_End   = { wchar_t(0x044F), wchar_t(0x0000) };
    static std::wstring const ie_End   = { wchar_t(0x0435), wchar_t(0x0000) };
    static std::wstring const i_End    = { wchar_t(0x0438), wchar_t(0x0000) };
    static std::wstring const yeru_End = { wchar_t(0x044B), wchar_t(0x0000) };
    static std::wstring const u_End    = { wchar_t(0x0443), wchar_t(0x0000) };
    static std::wstring const yu_End   = { wchar_t(0x044E), wchar_t(0x0000) };
    static std::wstring const oj_End   = { wchar_t(0x043E), wchar_t(0x0439), wchar_t(0x0000) };
    static std::wstring const ie_j_End = { wchar_t(0x0435), wchar_t(0x0439), wchar_t(0x0000) };
    static std::wstring const io_j_End = { wchar_t(0x0451), wchar_t(0x0439), wchar_t(0x0000) };
    static std::wstring const o_m_End  = { wchar_t(0x043E), wchar_t(0x043C), wchar_t(0x0000) };
    static std::wstring const io_m_End = { wchar_t(0x0451), wchar_t(0x043C), wchar_t(0x0000) };
    static std::wstring const ie_m_End = { wchar_t(0x0435), wchar_t(0x043C), wchar_t(0x0000) };
    static std::wstring const soft_End = { wchar_t(0x044C), wchar_t(0x0000) };
    static std::wstring const j_End    = { wchar_t(0x0439), wchar_t(0x0000) };
 
    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 (auto itr = endings.begin(), end = endings.end(); (itr != end) && *itr; ++itr)
    {
        std::wstring const& ending = **itr;
        std::size_t const endLen = ending.length();
        if (endLen > thisLen)
        {
            continue;
        }
 
        if (wname.substr(thisLen - endLen, thisLen) == ending)
        {
            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() [1/3]

template<typename T >

std::string GetTypeName

(

)

{ return GetTypeName(typeid(T)); }

References GetTypeName().

Referenced by GetTypeName().

GetTypeName() [2/3]

AC_COMMON_API std::string GetTypeName

(

std::type_info const &

info

)

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

GetTypeName() [3/3]

template<typename T >

std::enable_if_t<!std::is_same_v< std::decay_t< T >, std::type_info >, std::string > GetTypeName

(

T &&

v

)

{ return GetTypeName(typeid(v)); }

References GetTypeName().

HexStrToByteArray() [1/2]

template<size_t Size>

std::array< uint8, Size > HexStrToByteArray	(	std::string_view	str,
		bool	reverse = false
	)

{
    std::array<uint8, Size> arr;
    HexStrToByteArray(str, arr, reverse);
    return arr;
}

References HexStrToByteArray().

HexStrToByteArray() [2/2]

template<size_t Size>

void HexStrToByteArray	(	std::string_view	str,
		std::array< uint8, Size > &	buf,
		bool	reverse = false
	)

{
    Acore::Impl::HexStrToByteArray(str, buf.data(), Size, reverse);
}

References Acore::Impl::HexStrToByteArray().

Referenced by HexStrToByteArray(), and RealmList::LoadBuildInfo().

isBasicLatinCharacter()

bool isBasicLatinCharacter ( wchar_t  wchar )

inline

{
    if (wchar >= L'a' && wchar <= L'z')                      // LATIN SMALL LETTER A - LATIN SMALL LETTER Z
    {
        return true;
    }
    if (wchar >= L'A' && wchar <= L'Z')                      // LATIN CAPITAL LETTER A - LATIN CAPITAL LETTER Z
    {
        return true;
    }
    return false;
}

Referenced by isBasicLatinString(), isExtendedLatinCharacter(), and wcharToUpperOnlyLatin().

isBasicLatinString()

bool isBasicLatinString ( std::wstring_view  wstr, bool  numericOrSpace  )

inline

{
    for (wchar_t i : wstr)
        if (!isBasicLatinCharacter(i) && (!numericOrSpace || !isNumericOrSpace(i)))
        {
            return false;
        }
    return true;
}

References isBasicLatinCharacter(), and isNumericOrSpace().

Referenced by isValidString().

isCyrillicCharacter()

bool isCyrillicCharacter ( wchar_t  wchar )

inline

{
    if (wchar >= 0x0410 && wchar <= 0x044F)                  // CYRILLIC CAPITAL LETTER A - CYRILLIC SMALL LETTER YA
    {
        return true;
    }
    if (wchar == 0x0401 || wchar == 0x0451)                  // CYRILLIC CAPITAL LETTER IO, CYRILLIC SMALL LETTER IO
    {
        return true;
    }
    return false;
}

Referenced by GetMainPartOfName(), WorldSession::HandleSetPlayerDeclinedNames(), and isCyrillicString().

isCyrillicString()

bool isCyrillicString ( std::wstring_view  wstr, bool  numericOrSpace  )

inline

{
    for (wchar_t i : wstr)
        if (!isCyrillicCharacter(i) && (!numericOrSpace || !isNumericOrSpace(i)))
        {
            return false;
        }
    return true;
}

References isCyrillicCharacter(), and isNumericOrSpace().

Referenced by isValidString().

isEastAsianCharacter()

bool isEastAsianCharacter ( wchar_t  wchar )

inline

{
    if (wchar >= 0x1100 && wchar <= 0x11F9)                  // Hangul Jamo
    {
        return true;
    }
    if (wchar >= 0x3041 && wchar <= 0x30FF)                  // Hiragana + Katakana
    {
        return true;
    }
    if (wchar >= 0x3131 && wchar <= 0x318E)                  // Hangul Compatibility Jamo
    {
        return true;
    }
    if (wchar >= 0x31F0 && wchar <= 0x31FF)                  // Katakana Phonetic Ext.
    {
        return true;
    }
    if (wchar >= 0x3400 && wchar <= 0x4DB5)                  // CJK Ideographs Ext. A
    {
        return true;
    }
    if (wchar >= 0x4E00 && wchar <= 0x9FC3)                  // Unified CJK Ideographs
    {
        return true;
    }
    if (wchar >= 0xAC00 && wchar <= 0xD7A3)                  // Hangul Syllables
    {
        return true;
    }
    if (wchar >= 0xFF01 && wchar <= 0xFFEE)                  // Halfwidth forms
    {
        return true;
    }
    return false;
}

Referenced by isEastAsianString().

isEastAsianString()

bool isEastAsianString ( std::wstring_view  wstr, bool  numericOrSpace  )

inline

{
    for (wchar_t i : wstr)
        if (!isEastAsianCharacter(i) && (!numericOrSpace || !isNumericOrSpace(i)))
        {
            return false;
        }
    return true;
}

References isEastAsianCharacter(), and isNumericOrSpace().

Referenced by isValidString().

IsEvenNumber()

bool IsEvenNumber ( int32  n )

inline

{
    return n % 2 == 0;
}

Referenced by boss_mechano_lord_capacitus::JustEngagedWith().

isExtendedLatinCharacter()

bool isExtendedLatinCharacter ( wchar_t  wchar )

inline

{
    if (isBasicLatinCharacter(wchar))
    {
        return true;
    }
    if (wchar >= 0x00C0 && wchar <= 0x00D6)                  // LATIN CAPITAL LETTER A WITH GRAVE - LATIN CAPITAL LETTER O WITH DIAERESIS
    {
        return true;
    }
    if (wchar >= 0x00D8 && wchar <= 0x00DE)                  // LATIN CAPITAL LETTER O WITH STROKE - LATIN CAPITAL LETTER THORN
    {
        return true;
    }
    if (wchar == 0x00DF)                                     // LATIN SMALL LETTER SHARP S
    {
        return true;
    }
    if (wchar >= 0x00E0 && wchar <= 0x00F6)                  // LATIN SMALL LETTER A WITH GRAVE - LATIN SMALL LETTER O WITH DIAERESIS
    {
        return true;
    }
    if (wchar >= 0x00F8 && wchar <= 0x00FE)                  // LATIN SMALL LETTER O WITH STROKE - LATIN SMALL LETTER THORN
    {
        return true;
    }
    if (wchar >= 0x0100 && wchar <= 0x012F)                  // LATIN CAPITAL LETTER A WITH MACRON - LATIN SMALL LETTER I WITH OGONEK
    {
        return true;
    }
    if (wchar == 0x1E9E)                                     // LATIN CAPITAL LETTER SHARP S
    {
        return true;
    }
    return false;
}

References isBasicLatinCharacter().

Referenced by isExtendedLatinString().

isExtendedLatinString()

bool isExtendedLatinString ( std::wstring_view  wstr, bool  numericOrSpace  )

inline

{
    for (wchar_t i : wstr)
        if (!isExtendedLatinCharacter(i) && (!numericOrSpace || !isNumericOrSpace(i)))
        {
            return false;
        }
    return true;
}

References isExtendedLatinCharacter(), and isNumericOrSpace().

Referenced by isValidString().

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;
}

References Acore::Net::make_address().

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

isNumeric() [1/3]

bool isNumeric ( char  c )

inline

{
    return (c >= '0' && c <= '9');
}

isNumeric() [2/3]

bool isNumeric ( char const *  str )

inline

{
    for (char const* c = str; *c; ++c)
        if (!isNumeric(*c))
        {
            return false;
        }
 
    return true;
}

References isNumeric().

isNumeric() [3/3]

bool isNumeric ( wchar_t  wchar )

inline

{
    return (wchar >= L'0' && wchar <= L'9');
}

Referenced by character_commandscript::GetDeletedCharacterInfoList(), guild_commandscript::HandleGuildInfoCommand(), anonymous_namespace{Config.cpp}::IniKeyToEnvVarKey(), isNumeric(), and isNumericOrSpace().

isNumericOrSpace()

bool isNumericOrSpace ( wchar_t  wchar )

inline

{
    return isNumeric(wchar) || wchar == L' ';
}

References isNumeric().

Referenced by isBasicLatinString(), isCyrillicString(), isEastAsianString(), and isExtendedLatinString().

MoneyStringToMoney()

AC_COMMON_API 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().

RoundToInterval()

template<class T >

T RoundToInterval ( T &  num, T  floor, T  ceil  )

inline

{
    return num = std::min<T>(std::max<T>(num, floor), ceil);
}

Referenced by Unit::CalcAbsorbResist(), and npc_echo_of_medivh::HandlePieceMoveByAI().

secsToTimeString()

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

{
    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()

AC_COMMON_API 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()

AC_COMMON_API 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()

AC_COMMON_API bool StringEqualI	(	std::string_view	str1,
		std::string_view	str2
	)

{
    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().

StringStartsWith()

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

inline

{ return (haystack.substr(0, needle.length()) == needle); }

Referenced by cast_commandscript::GetTriggerFlags(), server_commandscript::HandleServerSetClosedCommand(), and Acore::Impl::ChatCommands::ArgInfo< Acore::ChatCommands::Variant< Ts... > >::TryAtIndex().

StringStartsWithI()

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

inline

{ return StringEqualI(haystack.substr(0, needle.length()), needle); }

References StringEqualI().

Referenced by Acore::Impl::ChatCommands::FilteredCommandListIterator::_skip(), and Acore::Impl::ChatCommands::ArgInfo< T, std::enable_if_t< std::is_enum_v< T > > >::Match().

stripLineInvisibleChars()

void stripLineInvisibleChars

(

std::string &

src

)

{
    static std::string const invChars = " \t\7\n";
 
    size_t wpos = 0;
 
    bool space = false;
    for (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();
    }
}

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()

AC_COMMON_API 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()

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::ChangePassword(), AccountMgr::ChangeUsername(), and AccountMgr::CreateAccount().

utf8printf()

AC_COMMON_API 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()

AC_COMMON_API 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()

AC_COMMON_API 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::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::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/3]

AC_COMMON_API bool Utf8toWStr	(	char const *	utf8str,
		size_t	csize,
		wchar_t *	wstr,
		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(), 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::LoadProfanityPlayersNames(), ObjectMgr::LoadReservedPlayersNames(), normalizePlayerName(), ProfanityNames(), ReservedNames(), Acore::ChatCommands::WTail::TryConsume(), Acore::Impl::ChatCommands::ArgInfo< std::wstring, void >::TryConsume(), WhoListCacheMgr::Update(), Utf8FitTo(), utf8ToConsole(), Utf8ToUpperOnlyLatin(), and vutf8printf().

Utf8toWStr() [2/3]

AC_COMMON_API 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().

Utf8toWStr() [3/3]

bool Utf8toWStr ( std::string_view  utf8str, wchar_t *  wstr, size_t &  wsize  )

inline

{
    return Utf8toWStr(utf8str.data(), utf8str.size(), wstr, wsize);
}

References Utf8toWStr().

utf8truncate()

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

{
    try
    {
        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().

ValueContainsStringI()

template<typename T >

bool ValueContainsStringI ( std::pair< T, std::string_view > const &  haystack, std::string_view  needle  )

inline

{
    return StringContainsStringI(haystack.second, needle);
}

References StringContainsStringI().

vutf8printf()

AC_COMMON_API 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];
 
    size_t temp_len = vsnprintf(temp_buf, 32 * 1024, str, *ap);
    //vsnprintf returns -1 if the buffer is too small
    if (temp_len == size_t(-1))
    {
        temp_len = 32 * 1024 - 1;
    }
 
    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().

wcharToLower()

wchar_t wcharToLower ( wchar_t  wchar )

inline

{
    if (wchar >= L'A' && wchar <= L'Z')                      // LATIN CAPITAL LETTER A - LATIN CAPITAL LETTER Z
    {
        return wchar_t(uint16(wchar) + 0x0020);
    }
    if (wchar >= 0x00C0 && wchar <= 0x00D6)                  // LATIN CAPITAL LETTER A WITH GRAVE - LATIN CAPITAL LETTER O WITH DIAERESIS
    {
        return wchar_t(uint16(wchar) + 0x0020);
    }
    if (wchar >= 0x00D8 && wchar <= 0x00DE)                  // LATIN CAPITAL LETTER O WITH STROKE - LATIN CAPITAL LETTER THORN
    {
        return wchar_t(uint16(wchar) + 0x0020);
    }
    if (wchar >= 0x0100 && wchar <= 0x012E)                  // LATIN CAPITAL LETTER A WITH MACRON - LATIN CAPITAL LETTER I WITH OGONEK (only %2=0)
    {
        if (wchar % 2 == 0)
        {
            return wchar_t(uint16(wchar) + 0x0001);
        }
    }
    if (wchar == 0x1E9E)                                     // LATIN CAPITAL LETTER SHARP S
    {
        return wchar_t(0x00DF);
    }
    if (wchar == 0x0401)                                     // CYRILLIC CAPITAL LETTER IO
    {
        return wchar_t(0x0451);
    }
    if (wchar >= 0x0410 && wchar <= 0x042F)                  // CYRILLIC CAPITAL LETTER A - CYRILLIC CAPITAL LETTER YA
    {
        return wchar_t(uint16(wchar) + 0x0020);
    }
 
    return wchar;
}

Referenced by wstrToLower().

wcharToUpper()

wchar_t wcharToUpper ( wchar_t  wchar )

inline

{
    if (wchar >= L'a' && wchar <= L'z')                      // LATIN SMALL LETTER A - LATIN SMALL LETTER Z
    {
        return wchar_t(uint16(wchar) - 0x0020);
    }
    if (wchar == 0x00DF)                                     // LATIN SMALL LETTER SHARP S
    {
        return wchar_t(0x1E9E);
    }
    if (wchar >= 0x00E0 && wchar <= 0x00F6)                  // LATIN SMALL LETTER A WITH GRAVE - LATIN SMALL LETTER O WITH DIAERESIS
    {
        return wchar_t(uint16(wchar) - 0x0020);
    }
    if (wchar >= 0x00F8 && wchar <= 0x00FE)                  // LATIN SMALL LETTER O WITH STROKE - LATIN SMALL LETTER THORN
    {
        return wchar_t(uint16(wchar) - 0x0020);
    }
    if (wchar >= 0x0101 && wchar <= 0x012F)                  // LATIN SMALL LETTER A WITH MACRON - LATIN SMALL LETTER I WITH OGONEK (only %2=1)
    {
        if (wchar % 2 == 1)
        {
            return wchar_t(uint16(wchar) - 0x0001);
        }
    }
    if (wchar >= 0x0430 && wchar <= 0x044F)                  // CYRILLIC SMALL LETTER A - CYRILLIC SMALL LETTER YA
    {
        return wchar_t(uint16(wchar) - 0x0020);
    }
    if (wchar == 0x0451)                                     // CYRILLIC SMALL LETTER IO
    {
        return wchar_t(0x0401);
    }
 
    return wchar;
}

Referenced by normalizePlayerName(), wcharToUpperOnlyLatin(), and wstrToUpper().

wcharToUpperOnlyLatin()

wchar_t wcharToUpperOnlyLatin ( wchar_t  wchar )

inline

{
    return isBasicLatinCharacter(wchar) ? wcharToUpper(wchar) : wchar;
}

References isBasicLatinCharacter(), and wcharToUpper().

Referenced by Utf8ToUpperOnlyLatin().

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::LoadProfanityPlayersNames(), ObjectMgr::LoadReservedPlayersNames(), 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]

AC_COMMON_API 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]

AC_COMMON_API bool WStrToUtf8	(	wchar_t const *	wstr,
		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().