ObjectGuid.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * 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 2 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/>.
 */
 
#include "ObjectGuid.h"
#include "ByteBuffer.h"
#include "Errors.h"
#include "RealmList.h"
#include "StringFormat.h"
#include "Util.h"
#include <bit>
#include <charconv>
 
static_assert(sizeof(ObjectGuid) == sizeof(uint64) * 2, "ObjectGuid must be exactly 16 bytes");
 
namespace
{
    struct ObjectGuidInfo
    {
        using FormatFunction = fmt::appender(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid);
        using ParseFunction = ObjectGuid(HighGuid type, std::string_view guidString);
 
        std::string_view Names[AsUnderlyingType(HighGuid::Count)];
        std::array<FormatFunction*, AsUnderlyingType(HighGuid::Count)> ClientFormatFunction;
        std::array<ParseFunction*, AsUnderlyingType(HighGuid::Count)> ClientParseFunction;
 
        static std::string Format(ObjectGuid const& guid)
        {
            return Trinity::StringFormat("{}", guid);
        }
 
        ObjectGuid Parse(std::string_view guidString) const
        {
            std::size_t typeEnd = guidString.find('-');
            if (typeEnd == std::string::npos)
            {
                if (guidString == "0000000000000000")
                    return ObjectGuid::Empty;
                return ObjectGuid::FromStringFailed;
            }
 
            std::string_view typeStr = guidString.substr(0, typeEnd);
            guidString.remove_prefix(typeEnd + 1);
 
            // find correct parser for type name
            for (int32 type = 0; type < AsUnderlyingType(HighGuid::Count); ++type)
                if (typeStr == Names[type])
                    return ClientParseFunction[type](HighGuid(type), guidString);
 
            return ObjectGuid::FromStringFailed;
        }
 
        struct FormatPadding { std::ptrdiff_t Value; constexpr operator std::ptrdiff_t() const { return Value; } };
 
        template <std::ptrdiff_t Width>
        static constexpr inline FormatPadding padding{ .Value = Width };
        static constexpr inline FormatPadding no_padding{ .Value = 0 };
 
        struct FormatBase { int32 Value; constexpr operator int32() const { return Value; } };
 
        static constexpr inline FormatBase dec{ 10 };
        static constexpr inline FormatBase hex{ 16 };
 
        static fmt::appender AppendTypeName(fmt::format_context& ctx, std::string_view type)
        {
            return std::ranges::copy(type, ctx.out()).out;
        }
 
        template <FormatPadding Width, FormatBase Base>
        static fmt::appender AppendComponent(fmt::format_context& ctx, uint64 component)
        {
            *ctx.out() = '-';
 
            std::array<char, 20> buf;
            auto [end, err] = std::to_chars(buf.data(), buf.data() + buf.size(), component, Base);
 
            ASSERT(err == std::errc(), "Failed to convert guid part to string");
 
            if constexpr (Width != 0)
            {
                if (std::ptrdiff_t written =  std::distance(buf.data(), end); written < Width)
                    std::ranges::fill_n(ctx.out(), Width - written, '0');
            }
 
            if constexpr (Base > 10)
                return std::ranges::transform(buf.data(), end, ctx.out(), charToUpper).out;
            else
                return std::ranges::copy(buf.data(), end, ctx.out()).out;
        }
 
        static fmt::appender AppendComponent(fmt::format_context& ctx, std::string_view component)
        {
            *ctx.out() = '-';
            return std::ranges::copy(component, ctx.out()).out;
        }
 
        template <FormatBase Base, typename T>
        static bool ParseComponent(std::string_view& input, T* component)
        {
            auto [end, err] = std::from_chars(input.data(), input.data() + input.length(), *component, Base);
            if (err != std::errc())
                return false;
 
            input.remove_prefix(end - input.data());
            if (!input.empty())
            {
                if (input[0] != '-')
                    return false;
 
                input.remove_prefix(1);
            }
 
            return true;
        }
 
        static bool ParseDone(std::string_view const& sv) { return sv.empty(); }
 
        static fmt::appender FormatNull(fmt::format_context& ctx, std::string_view /*typeName*/, ObjectGuid const& /*guid*/)
        {
            return std::ranges::fill_n(ctx.out(), 16, '0');
        }
 
        static ObjectGuid ParseNull(HighGuid, std::string_view)
        {
            return ObjectGuid::Empty;
        }
 
        static constexpr std::array<std::string_view, 20> UniqNames =
        {
            "",
            "WOWGUID_UNIQUE_PROBED_DELETE",
            "WOWGUID_UNIQUE_JAM_TEMP",
            "WOWGUID_TO_STRING_FAILED",
            "WOWGUID_FROM_STRING_FAILED",
            "WOWGUID_UNIQUE_SERVER_SELF",
            "WOWGUID_UNIQUE_MAGIC_SELF",
            "WOWGUID_UNIQUE_MAGIC_PET",
            "WOWGUID_UNIQUE_INVALID_TRANSPORT",
            "WOWGUID_UNIQUE_AMMO_ID",
            "WOWGUID_SPELL_TARGET_TRADE_ITEM",
            "WOWGUID_SCRIPT_TARGET_INVALID",
            "WOWGUID_SCRIPT_TARGET_NONE",
            "",
            "WOWGUID_FAKE_MODERATOR",
            "",
            "",
            "WOWGUID_UNIQUE_ACCOUNT_OBJ_INITIALIZATION",
            "",
            "WOWGUID_PENDING_PERMANENT_CHARACTER_ASSIGNMENT"
        };
 
        static fmt::appender FormatUniq(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ObjectGuid::LowType id = guid.GetCounter();
            if (id >= UniqNames.size() || UniqNames[id].empty())
                id = 3;
 
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent(ctx, UniqNames[id]));
            return ctx.out();
        }
 
        static ObjectGuid ParseUniq(HighGuid /*type*/, std::string_view guidString)
        {
            for (std::size_t id = 0; id < UniqNames.size(); ++id)
            {
                if (UniqNames[id].empty())
                    continue;
 
                if (guidString == UniqNames[id])
                    return ObjectGuidFactory::CreateUniq(id);
            }
 
            return ObjectGuid::FromStringFailed;
        }
 
        static fmt::appender FormatPlayer(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRealmId()));
            switch (uint8 subType = (guid.GetRawValue(1) >> 40) & 0x3)
            {
                case 0:
                    // no subType
                    ctx.advance_to(AppendComponent<padding<8>, hex>(ctx, guid.GetRawValue(0)));
                    break;
                case 1: // characterless (plunderstorm)
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, subType));
                    ctx.advance_to(AppendComponent<padding<16>, hex>(ctx, guid.GetRawValue(0)));
                    break;
                case 2: // npc-as-player
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, subType));
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 16 & 0xFFFFFF)); // creature id?
                    ctx.advance_to(AppendComponent<padding<16>, hex>(ctx, guid.GetRawValue(0)));
                    break;
                default:
                    break;
            }
 
            return ctx.out();
        }
 
        static ObjectGuid ParsePlayer(HighGuid /*type*/, std::string_view guidString)
        {
            uint32 realmId = 0;
            uint8 subType = 0;
            uint32 arg1 = 0;
            uint64 dbId = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &realmId)
                || !ParseComponent<hex>(guidString, &dbId))
                return ObjectGuid::FromStringFailed;
 
            if (!ParseDone(guidString))
            {
                // dbId holds playerType at this point
                switch (dbId)
                {
                    case 1: // characterless (plunderstorm)
                        break;
                    case 2: // npc-as-player
                        if (!ParseComponent<dec>(guidString, &arg1)) // creature id?
                            return ObjectGuid::FromStringFailed;
                        break;
                    default:
                        return ObjectGuid::FromStringFailed;
                }
 
                subType = dbId;
                if (!ParseComponent<hex>(guidString, &dbId)
                    || !ParseDone(guidString))
                    return ObjectGuid::FromStringFailed;
            }
 
            return ObjectGuidFactory::CreatePlayer(realmId, subType, arg1, dbId);
        }
 
        static fmt::appender FormatItem(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRealmId()));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 18 & 0xFFFFFF));
            ctx.advance_to(AppendComponent<padding<16>, hex>(ctx, guid.GetRawValue(0)));
            return ctx.out();
        }
 
        static ObjectGuid ParseItem(HighGuid /*type*/, std::string_view guidString)
        {
            uint32 realmId = 0;
            uint32 arg1 = 0;
            uint64 dbId = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &realmId)
                || !ParseComponent<dec>(guidString, &arg1)
                || !ParseComponent<hex>(guidString, &dbId)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateItem(realmId, dbId);
        }
 
        static fmt::appender FormatWorldObject(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetSubType()));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRealmId()));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetMapId()));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(0) >> 40 & 0xFFFFFF));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetEntry()));
            ctx.advance_to(AppendComponent<padding<10>, hex>(ctx, guid.GetCounter()));
            return ctx.out();
        }
 
        static ObjectGuid ParseWorldObject(HighGuid type, std::string_view guidString)
        {
            uint8 subType = 0;
            uint32 realmId = 0;
            uint16 mapId = 0;
            uint32 serverId = 0;
            uint32 id = 0;
            uint64 counter = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &subType)
                || !ParseComponent<dec>(guidString, &realmId)
                || !ParseComponent<dec>(guidString, &mapId)
                || !ParseComponent<dec>(guidString, &serverId)
                || !ParseComponent<dec>(guidString, &id)
                || !ParseComponent<hex>(guidString, &counter)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateWorldObject(type, subType, realmId, mapId, serverId, id, counter);
        }
 
        static fmt::appender FormatTransport(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetEntry()));
            ctx.advance_to(AppendComponent<padding<16>, hex>(ctx, guid.GetRawValue(0)));
            return ctx.out();
        }
 
        static ObjectGuid ParseTransport(HighGuid type, std::string_view guidString)
        {
            uint32 id = 0;
            uint32 counter = 0;
 
            if (!ParseComponent<dec>(guidString, &id)
                || !ParseComponent<hex>(guidString, &counter)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateTransport(type, counter);
        }
 
        static fmt::appender FormatClientActor(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRealmId()));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 26 & 0xFFFFFF));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(0) & 0xFFFFFFFF));
            return ctx.out();
        }
 
        static ObjectGuid ParseClientActor(HighGuid /*type*/, std::string_view guidString)
        {
            uint16 ownerType = 0;
            uint16 ownerId = 0;
            uint32 counter = 0;
 
            if (!ParseComponent<dec>(guidString, &ownerType)
                || !ParseComponent<dec>(guidString, &ownerId)
                || !ParseComponent<dec>(guidString, &counter)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateClientActor(ownerType, ownerId, counter);
        }
 
        static fmt::appender FormatChatChannel(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            uint32 builtIn = (guid.GetRawValue(1) >> 25) & 0x1;
            uint32 trade = (guid.GetRawValue(1) >> 24) & 0x1;
            uint32 zoneId = (guid.GetRawValue(1) >> 10) & 0x3FFF;
            uint32 factionGroupMask = (guid.GetRawValue(1) >> 4) & 0x3F;
 
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRealmId()));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, builtIn));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, trade));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, zoneId));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, factionGroupMask));
            ctx.advance_to(AppendComponent<padding<8>, hex>(ctx, guid.GetRawValue(0)));
            return ctx.out();
        }
 
        static ObjectGuid ParseChatChannel(HighGuid /*type*/, std::string_view guidString)
        {
            uint32 realmId = 0;
            uint32 builtIn = 0;
            uint32 trade = 0;
            uint16 zoneId = 0;
            uint8 factionGroupMask = 0;
            uint64 id = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &realmId)
                || !ParseComponent<dec>(guidString, &builtIn)
                || !ParseComponent<dec>(guidString, &trade)
                || !ParseComponent<dec>(guidString, &zoneId)
                || !ParseComponent<dec>(guidString, &factionGroupMask)
                || !ParseComponent<hex>(guidString, &id)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateChatChannel(realmId, builtIn != 0, trade != 0, zoneId, factionGroupMask, id);
        }
 
        static fmt::appender FormatGlobal(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) & 0x3FFFFFFFFFFFFFF));
            ctx.advance_to(AppendComponent<padding<12>, hex>(ctx, guid.GetRawValue(0)));
            return ctx.out();
        }
 
        static ObjectGuid ParseGlobal(HighGuid type, std::string_view guidString)
        {
            uint64 dbIdHigh = UI64LIT(0);
            uint64 dbIdLow = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &dbIdHigh)
                || !ParseComponent<hex>(guidString, &dbIdLow)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateGlobal(type, dbIdHigh, dbIdLow);
        }
 
        static fmt::appender FormatGuild(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRealmId()));
            ctx.advance_to(AppendComponent<padding<12>, hex>(ctx, guid.GetRawValue(0)));
            return ctx.out();
        }
 
        static ObjectGuid ParseGuild(HighGuid type, std::string_view guidString)
        {
            uint32 realmId = 0;
            uint64 dbId = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &realmId)
                || !ParseComponent<hex>(guidString, &dbId)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateGuild(type, realmId, dbId);
        }
 
        static fmt::appender FormatMobileSession(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRealmId()));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 33 & 0x1FF));
            ctx.advance_to(AppendComponent<padding<8>, hex>(ctx, guid.GetRawValue(0)));
            return ctx.out();
        }
 
        static ObjectGuid ParseMobileSession(HighGuid /*type*/, std::string_view guidString)
        {
            uint32 realmId = 0;
            uint16 arg1 = 0;
            uint64 counter = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &realmId)
                || !ParseComponent<dec>(guidString, &arg1)
                || !ParseComponent<hex>(guidString, &counter)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateMobileSession(realmId, arg1, counter);
        }
 
        static fmt::appender FormatWebObj(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRealmId()));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 37 & 0x1F));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 35 & 0x3));
            ctx.advance_to(AppendComponent<padding<12>, hex>(ctx, guid.GetRawValue(0)));
            return ctx.out();
        }
 
        static ObjectGuid ParseWebObj(HighGuid /*type*/, std::string_view guidString)
        {
            uint32 realmId = 0;
            uint8 arg1 = 0;
            uint8 arg2 = 0;
            uint64 counter = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &realmId)
                || !ParseComponent<dec>(guidString, &arg1)
                || !ParseComponent<dec>(guidString, &arg2)
                || !ParseComponent<hex>(guidString, &counter)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateWebObj(realmId, arg1, arg2, counter);
        }
 
        static fmt::appender FormatLFGObject(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 54 & 0xF));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 50 & 0xF));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 46 & 0xF));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 38 & 0xFF));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 37 & 0x1));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 35 & 0x3));
            ctx.advance_to(AppendComponent<padding<6>, hex>(ctx, guid.GetRawValue(0)));
            return ctx.out();
        }
 
        static ObjectGuid ParseLFGObject(HighGuid /*type*/, std::string_view guidString)
        {
            uint8 arg1 = 0;
            uint8 arg2 = 0;
            uint8 arg3 = 0;
            uint8 arg4 = 0;
            uint8 arg5 = 0;
            uint8 arg6 = 0;
            uint64 counter = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &arg1)
                || !ParseComponent<dec>(guidString, &arg2)
                || !ParseComponent<dec>(guidString, &arg3)
                || !ParseComponent<dec>(guidString, &arg4)
                || !ParseComponent<dec>(guidString, &arg5)
                || !ParseComponent<dec>(guidString, &arg6)
                || !ParseComponent<hex>(guidString, &counter)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateLFGObject(arg1, arg2, arg3, arg4, arg5 != 0, arg6, counter);
        }
 
        static fmt::appender FormatLFGList(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 54 & 0xF));
            ctx.advance_to(AppendComponent<padding<6>, hex>(ctx, guid.GetRawValue(0)));
            return ctx.out();
        }
 
        static ObjectGuid ParseLFGList(HighGuid /*type*/, std::string_view guidString)
        {
            uint8 arg1 = 0;
            uint64 counter = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &arg1)
                || !ParseComponent<hex>(guidString, &counter)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateLFGList(arg1, counter);
        }
 
        static fmt::appender FormatClient(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRealmId()));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) >> 10 & 0xFFFFFFFF));
            ctx.advance_to(AppendComponent<padding<12>, hex>(ctx, guid.GetRawValue(0)));
            return ctx.out();
        }
 
        static ObjectGuid ParseClient(HighGuid type, std::string_view guidString)
        {
            uint32 realmId = 0;
            uint32 arg1 = 0;
            uint64 counter = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &realmId)
                || !ParseComponent<dec>(guidString, &arg1)
                || !ParseComponent<hex>(guidString, &counter)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateClient(type, realmId, arg1, counter);
        }
 
        static fmt::appender FormatClubFinder(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            uint32 type = uint32(guid.GetRawValue(1) >> 33) & 0xFF;
            uint32 clubFinderId = uint32(guid.GetRawValue(1)) & 0xFFFFFFFF;
 
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, type));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, clubFinderId));
            switch (type)
            {
                case 0: // club
                    ctx.advance_to(AppendComponent<padding<16>, hex>(ctx, guid.GetRawValue(0))); // clubId
                    break;
                case 1: // guild
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRealmId()));
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(0))); // guildId
                    break;
                default:
                    break;
            }
 
            return ctx.out();
        }
 
        static ObjectGuid ParseClubFinder(HighGuid /*type*/, std::string_view guidString)
        {
            uint8 type = 0;
            uint32 clubFinderId = 0;
            uint32 realmId = 0;
            uint64 dbId = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &type)
                || !ParseComponent<dec>(guidString, &clubFinderId))
                return ObjectGuid::FromStringFailed;
 
            switch (type)
            {
                case 0: // club
                    if (!ParseComponent<hex>(guidString, &dbId))
                        return ObjectGuid::FromStringFailed;
                    break;
                case 1: // guild
                    if (!ParseComponent<dec>(guidString, &realmId)
                        || !ParseComponent<dec>(guidString, &dbId))
                        return ObjectGuid::FromStringFailed;
                    break;
                default:
                    return ObjectGuid::FromStringFailed;
            }
 
            if (!ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateClubFinder(realmId, type, clubFinderId, dbId);
        }
 
        static fmt::appender FormatToolsClient(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetMapId()));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(0) >> 40 & 0xFFFFFF));
            ctx.advance_to(AppendComponent<padding<10>, hex>(ctx, guid.GetCounter()));
            return ctx.out();
        }
 
        static ObjectGuid ParseToolsClient(HighGuid /*type*/, std::string_view guidString)
        {
            uint16 mapId = 0;
            uint32 serverId = 0;
            uint64 counter = UI64LIT(0);
 
            if (!ParseComponent<dec>(guidString, &mapId)
                || !ParseComponent<dec>(guidString, &serverId)
                || !ParseComponent<hex>(guidString, &counter)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateToolsClient(mapId, serverId, counter);
        }
 
        static fmt::appender FormatWorldLayer(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<padding<0>, hex>(ctx, guid.GetRawValue(1) >> 10 & 0xFFFFFFFF));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(1) & 0x1FF));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(0) >> 24 & 0xFF));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(0) & 0x7FFFFF));
            return ctx.out();
        }
 
        static ObjectGuid ParseWorldLayer(HighGuid /*type*/, std::string_view guidString)
        {
            uint32 arg1 = 0;
            uint16 arg2 = 0;
            uint8 arg3 = 0;
            uint32 arg4 = 0;
 
            if (!ParseComponent<hex>(guidString, &arg1)
                || !ParseComponent<dec>(guidString, &arg2)
                || !ParseComponent<dec>(guidString, &arg3)
                || !ParseComponent<dec>(guidString, &arg4)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateWorldLayer(arg1, arg2, arg3, arg4);
        }
 
        static fmt::appender FormatLMMLobby(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRealmId()));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, uint32(guid.GetRawValue(1) >> 26) & 0xFFFFFF));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, uint32(guid.GetRawValue(1) >> 18) & 0xFF));
            ctx.advance_to(AppendComponent<no_padding, dec>(ctx, uint32(guid.GetRawValue(1) >> 10) & 0xFF));
            ctx.advance_to(AppendComponent<padding<0>, hex>(ctx, guid.GetRawValue(0)));
            return ctx.out();
        }
 
        static ObjectGuid ParseLMMLobby(HighGuid /*type*/, std::string_view guidString)
        {
            uint32 realmId = 0;
            uint32 arg2 = 0;
            uint8 arg3 = 0;
            uint8 arg4 = 0;
            uint64 arg5 = 0;
 
            if (!ParseComponent<dec>(guidString, &realmId)
                || !ParseComponent<dec>(guidString, &arg2)
                || !ParseComponent<dec>(guidString, &arg3)
                || !ParseComponent<dec>(guidString, &arg4)
                || !ParseComponent<hex>(guidString, &arg5)
                || !ParseDone(guidString))
                return ObjectGuid::FromStringFailed;
 
            return ObjectGuidFactory::CreateLMMLobby(realmId, arg2, arg3, arg4, arg5);
        }
 
        static fmt::appender FormatHousing(fmt::format_context& ctx, std::string_view typeName, ObjectGuid const& guid)
        {
            ctx.advance_to(AppendTypeName(ctx, typeName));
            switch (uint32 subType = (guid.GetRawValue(1) >> 53) & 0x1F)
            {
                case 1:
                case 4:
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, subType));
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, uint32(guid.GetRawValue(1) >> 32) & 0xFFFF));
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, uint32(guid.GetRawValue(1)) & 0xFFFFFFFF));
                    ctx.advance_to(AppendComponent<no_padding, hex>(ctx, guid.GetRawValue(0)));
                    break;
                case 2:
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, subType));
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, uint32(guid.GetRawValue(1)) & 0xFFFFFFFF));
                    ctx.advance_to(AppendComponent<no_padding, hex>(ctx, guid.GetRawValue(0)));
                    break;
                case 3:
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, subType));
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, uint32(guid.GetRawValue(1)) & 0x7FFF));
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, guid.GetRawValue(0)));
                    ctx.advance_to(AppendComponent<no_padding, dec>(ctx, uint32(guid.GetRawValue(1) >> 15) & 0x3F));
                    break;
                default:
                    break;
            }
            return ctx.out();
        }
 
        static ObjectGuid ParseHousing(HighGuid /*type*/, std::string_view guidString)
        {
            uint32 subType = 0;
 
            if (!ParseComponent<dec>(guidString, &subType))
                return ObjectGuid::FromStringFailed;
 
            uint32 arg1 = 0;
            uint32 arg2 = 0;
            uint64 arg3 = UI64LIT(0);
 
            switch (subType)
            {
                case 1:
                case 4:
                    if (!ParseComponent<dec>(guidString, &arg1)
                        || !ParseComponent<dec>(guidString, &arg2)
                        || !ParseComponent<hex>(guidString, &arg3)
                        || !ParseDone(guidString))
                        return ObjectGuid::FromStringFailed;
                    break;
                case 2:
                    if (!ParseComponent<dec>(guidString, &arg2)
                        || !ParseComponent<hex>(guidString, &arg3)
                        || !ParseDone(guidString))
                        return ObjectGuid::FromStringFailed;
                    break;
                case 3:
                    if (!ParseComponent<dec>(guidString, &arg2)
                        || !ParseComponent<dec>(guidString, &arg3)
                        || !ParseComponent<dec>(guidString, &arg1)
                        || !ParseDone(guidString))
                        return ObjectGuid::FromStringFailed;
                    break;
            }
 
            return ObjectGuidFactory::CreateHousing(subType, arg1, arg2, arg3);
        }
 
        ObjectGuidInfo();
    } Info;
 
    ObjectGuidInfo::ObjectGuidInfo()
    {
#define SET_GUID_INFO(type, format, parse) \
            Names[AsUnderlyingType(HighGuid::type)] = #type ## sv;\
            ClientFormatFunction[AsUnderlyingType(HighGuid::type)] = &ObjectGuidInfo::format;\
            ClientParseFunction[AsUnderlyingType(HighGuid::type)] = &ObjectGuidInfo::parse
 
        SET_GUID_INFO(Null, FormatNull, ParseNull);
        SET_GUID_INFO(Uniq, FormatUniq, ParseUniq);
        SET_GUID_INFO(Player, FormatPlayer, ParsePlayer);
        SET_GUID_INFO(Item, FormatItem, ParseItem);
        SET_GUID_INFO(WorldTransaction, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(StaticDoor, FormatTransport, ParseTransport);
        SET_GUID_INFO(Transport, FormatTransport, ParseTransport);
        SET_GUID_INFO(Conversation, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(Creature, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(Vehicle, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(Pet, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(GameObject, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(DynamicObject, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(AreaTrigger, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(Corpse, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(LootObject, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(SceneObject, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(Scenario, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(AIGroup, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(DynamicDoor, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(ClientActor, FormatClientActor, ParseClientActor);
        SET_GUID_INFO(Vignette, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(CallForHelp, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(AIResource, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(AILock, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(AILockTicket, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(ChatChannel, FormatChatChannel, ParseChatChannel);
        SET_GUID_INFO(Party, FormatGlobal, ParseGlobal);
        SET_GUID_INFO(Guild, FormatGuild, ParseGuild);
        SET_GUID_INFO(WowAccount, FormatGlobal, ParseGlobal);
        SET_GUID_INFO(BNetAccount, FormatGlobal, ParseGlobal);
        SET_GUID_INFO(GMTask, FormatGlobal, ParseGlobal);
        SET_GUID_INFO(MobileSession, FormatMobileSession, ParseMobileSession);
        SET_GUID_INFO(RaidGroup, FormatGlobal, ParseGlobal);
        SET_GUID_INFO(Spell, FormatGlobal, ParseGlobal);
        SET_GUID_INFO(Mail, FormatGlobal, ParseGlobal);
        SET_GUID_INFO(WebObj, FormatWebObj, ParseWebObj);
        SET_GUID_INFO(LFGObject, FormatLFGObject, ParseLFGObject);
        SET_GUID_INFO(LFGList, FormatLFGList, ParseLFGList);
        SET_GUID_INFO(UserRouter, FormatGlobal, ParseGlobal);
        SET_GUID_INFO(PVPQueueGroup, FormatGlobal, ParseGlobal);
        SET_GUID_INFO(UserClient, FormatGlobal, ParseGlobal);
        SET_GUID_INFO(PetBattle, FormatClient, ParseClient);
        SET_GUID_INFO(UniqUserClient, FormatClient, ParseClient);
        SET_GUID_INFO(BattlePet, FormatGlobal, ParseGlobal);
        SET_GUID_INFO(CommerceObj, FormatGlobal, ParseGlobal);
        SET_GUID_INFO(ClientSession, FormatClient, ParseClient);
        SET_GUID_INFO(Cast, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(ClientConnection, FormatClient, ParseClient);
        SET_GUID_INFO(ClubFinder, FormatClubFinder, ParseClubFinder);
        SET_GUID_INFO(ToolsClient, FormatToolsClient, ParseToolsClient);
        SET_GUID_INFO(WorldLayer, FormatWorldLayer, ParseWorldLayer);
        SET_GUID_INFO(ArenaTeam, FormatGuild, ParseGuild);
        SET_GUID_INFO(LMMParty, FormatClient, ParseClient);
        SET_GUID_INFO(LMMLobby, FormatLMMLobby, ParseLMMLobby);
        SET_GUID_INFO(Housing, FormatHousing, ParseHousing);
        SET_GUID_INFO(MeshObject, FormatWorldObject, ParseWorldObject);
        SET_GUID_INFO(Entity, FormatWorldObject, ParseWorldObject);
 
#undef SET_GUID_INFO
    }
}
 
template <typename FormatContext>
auto fmt::formatter<ObjectGuid>::format(ObjectGuid const& guid, FormatContext& ctx) const -> decltype(ctx.out())
{
    if (guid.GetHigh() >= HighGuid::Count)
        return this->format(ObjectGuid::ToStringFailed, ctx);
 
    int32 type = AsUnderlyingType(guid.GetHigh());
    if (!Info.ClientFormatFunction[type])
        return this->format(ObjectGuid::ToStringFailed, ctx);
 
    return Info.ClientFormatFunction[type](ctx, Info.Names[type], guid);
}
 
template TC_GAME_API fmt::appender fmt::formatter<ObjectGuid>::format<fmt::format_context>(ObjectGuid const&, format_context&) const;
 
std::string_view ObjectGuid::GetTypeName(HighGuid high)
{
    if (high >= HighGuid::Count)
        return "<unknown>";
 
    return Info.Names[uint32(high)];
}
 
std::string ObjectGuid::ToString() const
{
    return ObjectGuidInfo::Format(*this);
}
 
std::string ObjectGuid::ToHexString() const
{
    return Trinity::StringFormat("0x{:016X}{:016X}", _data[1], _data[0]);
}
 
ObjectGuid ObjectGuid::FromString(std::string_view guidString)
{
    return Info.Parse(guidString);
}
 
void ObjectGuid::SetRawValue(std::span<uint8 const> rawBytes)
{
    ASSERT(rawBytes.size() == BytesSize, SZFMTD " == " SZFMTD, rawBytes.size(), BytesSize);
    memcpy(_data.data(), rawBytes.data(), BytesSize);
}
 
static inline uint32 GetRealmIdForObjectGuid(uint32 realmId)
{
    if (realmId)
        return realmId;
 
    return sRealmList->GetCurrentRealmId().Realm;
}
 
constexpr ObjectGuid ObjectGuidFactory::CreateNull()
{
    return ObjectGuid();
}
 
constexpr ObjectGuid ObjectGuidFactory::CreateUniq(ObjectGuid::LowType id)
{
    return ObjectGuid(uint64(uint64(HighGuid::Uniq) << 58),
        id);
}
 
ObjectGuid ObjectGuidFactory::CreatePlayer(uint32 realmId, uint8 subType, uint32 arg1, ObjectGuid::LowType dbId)
{
    return ObjectGuid(uint64((uint64(HighGuid::Player) << 58)
        | (uint64(GetRealmIdForObjectGuid(realmId)) << 42)
        | (uint64(subType & 0x3) << 40)
        | (uint64(arg1 & 0xFFFFFF) << 16)),
        dbId);
}
 
ObjectGuid ObjectGuidFactory::CreateItem(uint32 realmId, ObjectGuid::LowType dbId)
{
    return ObjectGuid(uint64((uint64(HighGuid::Item) << 58)
        | (uint64(GetRealmIdForObjectGuid(realmId)) << 42)),
        dbId);
}
 
ObjectGuid ObjectGuidFactory::CreateWorldObject(HighGuid type, uint8 subType, uint32 realmId, uint16 mapId, uint32 serverId, uint32 entry, ObjectGuid::LowType counter)
{
    return ObjectGuid(uint64((uint64(type) << 58)
        | (uint64(GetRealmIdForObjectGuid(realmId) & 0x1FFF) << 42)
        | (uint64(mapId & 0x1FFF) << 29)
        | (uint64(entry & 0x7FFFFF) << 6)
        | (uint64(subType) & 0x3F)),
        uint64((uint64(serverId & 0xFFFFFF) << 40)
        | (counter & UI64LIT(0xFFFFFFFFFF))));
}
 
ObjectGuid ObjectGuidFactory::CreateTransport(HighGuid type, uint32 counter)
{
    return ObjectGuid(uint64((uint64(type) << 58)
        | (uint64(counter) << 38)),
        UI64LIT(0));
}
 
ObjectGuid ObjectGuidFactory::CreateClientActor(uint16 ownerType, uint16 ownerId, uint32 counter)
{
    return ObjectGuid(uint64((uint64(HighGuid::ClientActor) << 58)
        | (uint64(ownerType & 0x1FFF) << 42)
        | (uint64(ownerId & 0xFFFFFF) << 26)),
        uint64(counter));
}
 
ObjectGuid ObjectGuidFactory::CreateChatChannel(uint32 realmId, bool builtIn, bool trade, uint16 zoneId, uint8 factionGroupMask, ObjectGuid::LowType counter)
{
    return ObjectGuid(uint64((uint64(HighGuid::ChatChannel) << 58)
        | (uint64(GetRealmIdForObjectGuid(realmId) & 0x1FFF) << 42)
        | (uint64(builtIn) << 25)
        | (uint64(trade) << 24)
        | (uint64(zoneId & 0x3FFF) << 10)
        | (uint64(factionGroupMask & 0x3F) << 4)),
        counter);
}
 
ObjectGuid ObjectGuidFactory::CreateGlobal(HighGuid type, ObjectGuid::LowType dbIdHigh, ObjectGuid::LowType dbId)
{
    return ObjectGuid(uint64((uint64(type) << 58)
        | (uint64(dbIdHigh & UI64LIT(0x3FFFFFFFFFFFFFF)))),
        dbId);
}
 
ObjectGuid ObjectGuidFactory::CreateGuild(HighGuid type, uint32 realmId, ObjectGuid::LowType dbId)
{
    return ObjectGuid(uint64((uint64(type) << 58)
        | (uint64(GetRealmIdForObjectGuid(realmId)) << 42)),
        dbId);
}
 
ObjectGuid ObjectGuidFactory::CreateMobileSession(uint32 realmId, uint16 arg1, ObjectGuid::LowType counter)
{
    return ObjectGuid(uint64((uint64(HighGuid::MobileSession) << 58)
        | (uint64(GetRealmIdForObjectGuid(realmId)) << 42)
        | (uint64(arg1 & 0x1FF) << 33)),
        counter);
}
 
ObjectGuid ObjectGuidFactory::CreateWebObj(uint32 realmId, uint8 arg1, uint8 arg2, ObjectGuid::LowType counter)
{
    return ObjectGuid(uint64((uint64(HighGuid::WebObj) << 58)
        | (uint64(GetRealmIdForObjectGuid(realmId) & 0x1FFF) << 42)
        | (uint64(arg1 & 0x1F) << 37)
        | (uint64(arg2 & 0x3) << 35)),
        counter);
}
 
ObjectGuid ObjectGuidFactory::CreateLFGObject(uint8 arg1, uint8 arg2, uint8 arg3, uint8 arg4, bool arg5, uint8 arg6, ObjectGuid::LowType counter)
{
    return ObjectGuid(uint64((uint64(HighGuid::LFGObject) << 58)
        | (uint64(arg1 & 0xF) << 54)
        | (uint64(arg2 & 0xF) << 50)
        | (uint64(arg3 & 0xF) << 46)
        | (uint64(arg4 & 0xFF) << 38)
        | (uint64(arg5 ? 1 : 0) << 37)
        | (uint64(arg6 & 0x3) << 35)),
        counter);
}
 
ObjectGuid ObjectGuidFactory::CreateLFGList(uint8 arg1, ObjectGuid::LowType counter)
{
    return ObjectGuid(uint64((uint64(HighGuid::LFGObject) << 58)
        | (uint64(arg1 & 0xF) << 54)),
        counter);
}
 
ObjectGuid ObjectGuidFactory::CreateClient(HighGuid type, uint32 realmId, uint32 arg1, ObjectGuid::LowType counter)
{
    return ObjectGuid(uint64((uint64(type) << 58)
        | (uint64(GetRealmIdForObjectGuid(realmId) & 0x1FFF) << 42)
        | (uint64(arg1 & 0xFFFFFFFF) << 10)),
        counter);
}
 
ObjectGuid ObjectGuidFactory::CreateClubFinder(uint32 realmId, uint8 type, uint32 clubFinderId, ObjectGuid::LowType dbId)
{
    return ObjectGuid(uint64((uint64(HighGuid::ClubFinder) << 58)
        | (type == 1 ? (uint64(GetRealmIdForObjectGuid(realmId) & 0x1FFF) << 42) : UI64LIT(0))
        | (uint64(type & 0xFF) << 33)
        | (uint64(clubFinderId & 0xFFFFFFFF))),
        dbId);
}
 
ObjectGuid ObjectGuidFactory::CreateToolsClient(uint16 mapId, uint32 serverId, uint64 counter)
{
    return ObjectGuid(uint64((uint64(HighGuid::ToolsClient) << 58)
        | uint64(mapId)),
        uint64((uint64(serverId & 0xFFFFFF) << 40)
        | (counter & UI64LIT(0xFFFFFFFFFF))));
}
 
ObjectGuid ObjectGuidFactory::CreateWorldLayer(uint32 arg1, uint16 arg2, uint8 arg3, uint32 arg4)
{
    return ObjectGuid(uint64((uint64(HighGuid::WorldLayer) << 58)
        | (uint64(arg1 & 0xFFFFFFFF) << 10)
        | (uint64(arg2 & 0x1FF))),
        uint64((uint64(arg3 & 0xFF) << 24)
        | uint64(arg4 & 0x7FFFFF)));
}
 
ObjectGuid ObjectGuidFactory::CreateLMMLobby(uint32 realmId, uint32 arg2, uint8 arg3, uint8 arg4, ObjectGuid::LowType counter)
{
    return ObjectGuid(uint64((uint64(HighGuid::LMMLobby) << 58)
        | (uint64(GetRealmIdForObjectGuid(realmId)) << 42)
        | (uint64(arg2 & 0xFFFFFFFF) << 26)
        | (uint64(arg3 & 0xFF) << 18)
        | (uint64(arg4 & 0xFF) << 10)),
        counter);
}
 
ObjectGuid ObjectGuidFactory::CreateHousing(uint32 subType, uint32 arg1, uint32 arg2, uint64 arg3)
{
    switch (subType)
    {
        case 1:
        case 4:
            return ObjectGuid(uint64((uint64(HighGuid::Housing) << 58)
                | (uint64(subType & 0x1F) << 53)
                | (uint64(arg1 & 0xFFFF) << 32)
                | (uint64(arg2 & 0xFFFFFFFF))),
                arg3);
        case 2:
            return ObjectGuid(uint64((uint64(HighGuid::Housing) << 58)
                | (uint64(subType & 0x1F) << 53)
                | (uint64(arg2 & 0xFFFFFFFF))),
                arg3);
        case 3:
            return ObjectGuid(uint64((uint64(HighGuid::Housing) << 58)
                | (uint64(subType & 0x1F) << 53)
                | (uint64(arg1 & 0x3F) << 15)
                | (uint64(arg2 & 0x7FFF))),
                arg3);
        default:
            break;
    }
 
    return ObjectGuid::Empty;
}
 
ObjectGuid const ObjectGuid::Empty = ObjectGuid::Create<HighGuid::Null>();
ObjectGuid const ObjectGuid::ToStringFailed = ObjectGuid::Create<HighGuid::Uniq>(UI64LIT(3));
ObjectGuid const ObjectGuid::FromStringFailed = ObjectGuid::Create<HighGuid::Uniq>(UI64LIT(4));
ObjectGuid const ObjectGuid::TradeItem = ObjectGuid::Create<HighGuid::Uniq>(UI64LIT(10));
 
ByteBuffer& operator<<(ByteBuffer& buf, ObjectGuid const& guid)
{
    static constexpr std::ptrdiff_t NumUInt64s = std::tuple_size_v<decltype(ObjectGuid::_data)>;
 
    std::array<uint8, NumUInt64s + ObjectGuid::BytesSize> bytes;
    int32 mask = 0;
    int32 outputByteIndex = NumUInt64s;
    std::span<uint8 const, ObjectGuid::BytesSize> guidBytes = std::span<uint8 const, ObjectGuid::BytesSize>(reinterpret_cast<uint8 const*>(guid._data.data()), ObjectGuid::BytesSize);
 
    for (int32 inputByteIndex = 0; inputByteIndex < int32(ObjectGuid::BytesSize); ++inputByteIndex)
    {
        uint8 byte = guidBytes[inputByteIndex];
        bytes[outputByteIndex] = byte;
 
        int32 hasByte = (byte != 0) ? 1 : 0;
        mask |= hasByte << inputByteIndex;
        outputByteIndex += hasByte;
    }
 
    bytes[0] = mask & 0xFF;
    bytes[1] = (mask >> 8) & 0xFF;
    buf.append(bytes.data(), outputByteIndex);
 
    return buf;
}
 
ByteBuffer& operator>>(ByteBuffer& buf, ObjectGuid& guid)
{
    uint16 mask = buf.read<uint16>();
    std::span<uint8> bytes = buf.ReadBytes(std::popcount(mask));
 
    // check highest byte holding guid type
    // if it's 0 then we consider it empty and discard all sent bytes
    // return early to prevent reading out of bounds data
    if (!(mask & 0x8000))
    {
        guid.Clear();
        return buf;
    }
 
    std::span<uint8, ObjectGuid::BytesSize> guidBytes = std::span<uint8, ObjectGuid::BytesSize>(reinterpret_cast<uint8*>(guid._data.data()), ObjectGuid::BytesSize);
 
    for (std::size_t outputByteIndex = 0, inputByteIndex = 0; outputByteIndex < ObjectGuid::BytesSize; ++outputByteIndex)
    {
        int32 hasByte = (mask >> outputByteIndex) & 1;
        guidBytes[outputByteIndex] = bytes[inputByteIndex] & -hasByte;
        inputByteIndex += hasByte;
    }
 
    return buf;
}