Acore::Hyperlinks Namespace Reference

Namespaces
namespace	LinkTags

Classes
struct	AchievementLinkData
struct	GlyphLinkData
struct	HyperlinkColor
struct	HyperlinkInfo
struct	ItemLinkData
struct	QuestLinkData
struct	TalentLinkData
struct	TradeskillLinkData

Functions
HyperlinkInfo AC_GAME_API	ParseSingleHyperlink (std::string_view str)
bool AC_GAME_API	CheckAllLinks (std::string_view str)

Function Documentation

CheckAllLinks()

bool Acore::Hyperlinks::CheckAllLinks

(

std::string_view

str

)

{
    // Step 1: Disallow all control sequences except ||, |H, |h, |c and |r
    {
        std::string_view::size_type pos = 0;
        while ((pos = str.find('|', pos)) != std::string::npos)
        {
            ++pos;
            if (pos == str.length())
                return false;
            char next = str[pos];
            if (next == 'H' || next == 'h' || next == 'c' || next == 'r' || next == '|')
                ++pos;
            else
                return false;
        }
    }
 
    // Step 2: Parse all link sequences
    // They look like this: |c<color>|H<linktag>:<linkdata>|h[<linktext>]|h|r
    // - <color> is 8 hex characters AARRGGBB
    // - <linktag> is arbitrary length [a-z_]
    // - <linkdata> is arbitrary length, no | contained
    // - <linktext> is printable
    {
        std::string::size_type pos;
        while ((pos = str.find('|')) != std::string::npos)
        {
            if (str[pos + 1] == '|') // this is an escaped pipe character (||)
            {
                str = str.substr(pos + 2);
                continue;
            }
 
            HyperlinkInfo info = ParseSingleHyperlink(str.substr(pos));
            if (!info || !ValidateLinkInfo(info))
                return false;
 
            // tag is fine, find the next one
            str = info.tail;
        }
    }
 
    // all tags are valid
    return true;
}

References ParseSingleHyperlink(), Acore::Hyperlinks::HyperlinkInfo::tail, and ValidateLinkInfo().

Referenced by WorldPackets::Strings::Hyperlinks::Validate(), and WorldSession::ValidateHyperlinksAndMaybeKick().

ParseSingleHyperlink()

HyperlinkInfo Acore::Hyperlinks::ParseSingleHyperlink

(

std::string_view

str

)

{
    uint32 color = 0;
    std::string_view tag;
    std::string_view data;
    std::string_view text;
 
    //color tag
    if (str.substr(0, 2) != "|c")
        return {};
 
    str.remove_prefix(2);
 
    if (str.length() < 8)
        return {};
 
    for (uint8 i = 0; i < 8; ++i)
    {
        if (uint8 hex = toHex(str[i]))
            color = (color << 4) | (hex & 0xf);
        else
            return {};
    }
 
    str.remove_prefix(8);
 
    if (str.substr(0, 2) != "|H")
        return {};
 
    str.remove_prefix(2);
 
    // tag+data part follows
    if (size_t delimPos = str.find('|'); delimPos != std::string_view::npos)
    {
        tag = str.substr(0, delimPos);
        str.remove_prefix(delimPos+1);
    }
    else
        return {};
 
    // split tag if : is present (data separator)
    if (size_t dataStart = tag.find(':'); dataStart != std::string_view::npos)
    {
        data = tag.substr(dataStart+1);
        tag = tag.substr(0, dataStart);
    }
 
    // ok, next should be link data end tag...
    if (str.substr(0, 1) != "h")
        return {};
    str.remove_prefix(1);
    // skip to final |
    if (size_t end = str.find('|'); end != std::string_view::npos)
    {
        // check end tag
        if (str.substr(end, 4) != "|h|r")
            return {};
        // check text brackets
        if ((str[0] != '[') || (str[end - 1] != ']'))
            return {};
        text = str.substr(1, end - 2);
        // tail
        str = str.substr(end + 4);
    }
    else
        return {};
 
    // ok, valid hyperlink, return info
    return { str, color, tag, data, text };
}

References toHex().

Referenced by CheckAllLinks(), and Acore::ChatCommands::Hyperlink< linktag >::TryConsume().