BlockTypePalette.cpp

Go to the documentation of this file.

#include "Globals.h"
#include "BlockTypePalette.h"
#include "json/value.h"
#include "JsonUtils.h"
 
 
 
 
 
static size_t findNextSeparator(const AString & aString, size_t aStartIdx = 0)
{
    for (size_t i = aStartIdx, len = aString.length(); i < len; ++i)
    {
        switch (aString[i])
        {
            case '\t':
            case '\n':
            case '\r':
            {
                return i;
            }
        }
    }
    return AString::npos;
}
 
 
 
 
 
BlockTypePalette::BlockTypePalette():
    mMaxIndex(0)
{
}
 
 
 
 
 
UInt32 BlockTypePalette::index(const AString & aBlockTypeName, const BlockState & aBlockState)
{
    auto idx = maybeIndex(aBlockTypeName, aBlockState);
    if (idx.second)
    {
        return idx.first;
    }
 
    // Not found, append:
    auto index = mMaxIndex++;
    mBlockToNumber[aBlockTypeName][aBlockState] = index;
    mNumberToBlock[index] = {aBlockTypeName, aBlockState};
    return index;
}
 
 
 
 
 
std::pair<UInt32, bool> BlockTypePalette::maybeIndex(const AString & aBlockTypeName, const BlockState & aBlockState) const
{
    auto itr1 = mBlockToNumber.find(aBlockTypeName);
    if (itr1 == mBlockToNumber.end())
    {
        return {0, false};
    }
    auto itr2 = itr1->second.find(aBlockState);
    if (itr2 == itr1->second.end())
    {
        return {0, false};
    }
    return {itr2->second, true};
}
 
 
 
 
 
UInt32 BlockTypePalette::count() const
{
    return static_cast<UInt32>(mNumberToBlock.size());
}
 
 
 
 
 
const std::pair<AString, BlockState> & BlockTypePalette::entry(UInt32 aIndex) const
{
    auto itr = mNumberToBlock.find(aIndex);
    if (itr == mNumberToBlock.end())
    {
        throw NoSuchIndexException(aIndex);
    }
    return itr->second;
}
 
 
 
 
 
std::map<UInt32, UInt32> BlockTypePalette::createTransformMapAddMissing(const BlockTypePalette & aFrom)
{
    std::map<UInt32, UInt32> res;
    for (const auto & fromEntry: aFrom.mNumberToBlock)
    {
        auto fromIndex = fromEntry.first;
        const auto & blockTypeName = fromEntry.second.first;
        const auto & blockState = fromEntry.second.second;
        res[fromIndex] = index(blockTypeName, blockState);
    }
    return res;
}
 
 
 
 
 
std::map<UInt32, UInt32> BlockTypePalette::createTransformMapWithFallback(const BlockTypePalette & aFrom, UInt32 aFallbackIndex) const
{
    std::map<UInt32, UInt32> res;
    for (const auto & fromEntry: aFrom.mNumberToBlock)
    {
        auto fromIndex = fromEntry.first;
        const auto & blockTypeName = fromEntry.second.first;
        const auto & blockState = fromEntry.second.second;
        auto thisIndex = maybeIndex(blockTypeName, blockState);
        if (thisIndex.second)
        {
            // The entry was found in this
            res[fromIndex] = thisIndex.first;
        }
        else
        {
            // The entry was NOT found in this, replace with fallback:
            res[fromIndex] = aFallbackIndex;
        }
    }
    return res;
}
 
 
 
 
 
void BlockTypePalette::loadFromString(const AString & aString)
{
    static const AString hdrTsvRegular = "BlockTypePalette";
    static const AString hdrTsvUpgrade = "UpgradeBlockTypePalette";
 
    // Detect format by checking the header line (none -> JSON):
    if (aString.substr(0, hdrTsvRegular.length()) == hdrTsvRegular)
    {
        return loadFromTsv(aString, false);
    }
    else if (aString.substr(0, hdrTsvUpgrade.length()) == hdrTsvUpgrade)
    {
        return loadFromTsv(aString, true);
    }
    return loadFromJsonString(aString);
}
 
 
 
 
 
void BlockTypePalette::loadFromJsonString(const AString & aJsonPalette)
{
    // Parse the string into JSON object:
    Json::Value root;
    std::string errs;
    if (!JsonUtils::ParseString(aJsonPalette, root, &errs))
    {
        throw LoadFailedException(errs);
    }
 
    // Sanity-check the JSON's structure:
    if (!root.isObject())
    {
        throw LoadFailedException("Incorrect palette format, expected an object at root.");
    }
 
    // Load the palette:
    for (auto itr = root.begin(), end = root.end(); itr != end; ++itr)
    {
        const auto & blockTypeName = itr.name();
        const auto & states = (*itr)["states"];
        if (states == Json::Value())
        {
            throw LoadFailedException(fmt::format(FMT_STRING("Missing \"states\" for block type \"{}\""), blockTypeName));
        }
        for (const auto & state: states)
        {
            auto id = static_cast<UInt32>(std::stoul(state["id"].asString()));
            std::map<AString, AString> props;
            if (state.isMember("properties"))
            {
                const auto & properties = state["properties"];
                if (!properties.isObject())
                {
                    throw LoadFailedException(fmt::format(FMT_STRING("Member \"properties\" is not a JSON object (block type \"{}\", id {})."), blockTypeName, id));
                }
                for (const auto & key: properties.getMemberNames())
                {
                    props[key] = properties[key].asString();
                }
            }
            addMapping(id, blockTypeName, props);
        }
    }
}
 
 
 
 
 
void BlockTypePalette::loadFromTsv(const AString & aTsvPalette, bool aIsUpgrade)
{
    static const AString hdrTsvRegular = "BlockTypePalette";
    static const AString hdrTsvUpgrade = "UpgradeBlockTypePalette";
 
    // Check the file signature:
    auto idx = findNextSeparator(aTsvPalette);
    if ((idx == AString::npos) || (aTsvPalette[idx] == '\t'))
    {
        throw LoadFailedException("Invalid signature");
    }
    auto signature = aTsvPalette.substr(0, idx);
    bool isUpgrade = (signature == hdrTsvUpgrade);
    if (!isUpgrade && (signature != hdrTsvRegular))
    {
        throw LoadFailedException("Unknown signature");
    }
    if (aTsvPalette[idx] == '\r')   // CR of the CRLF pair, skip the LF:
    {
        idx += 1;
    }
 
    // Parse the header:
    bool hasHadVersion = false;
    AString commonPrefix;
    int line = 2;
    auto len = aTsvPalette.length();
    while (true)
    {
        auto keyStart = idx + 1;
        auto keyEnd = findNextSeparator(aTsvPalette, idx + 1);
        if (keyEnd == AString::npos)
        {
            throw LoadFailedException(fmt::format(FMT_STRING("Invalid header key format on line {}"), line));
        }
        if (keyEnd == idx + 1)  // Empty line, end of headers
        {
            if (aTsvPalette[keyEnd] == '\r')  // CR of the CRLF pair, skip the LF:
            {
                ++keyEnd;
            }
            idx = keyEnd;
            ++line;
            break;
        }
        auto valueEnd = findNextSeparator(aTsvPalette, keyEnd + 1);
        if ((valueEnd == AString::npos) || (aTsvPalette[valueEnd] == '\t'))
        {
            throw LoadFailedException(fmt::format(FMT_STRING("Invalid header value format on line {}"), line));
        }
        auto key = aTsvPalette.substr(keyStart, keyEnd - keyStart);
        if (key == "FileVersion")
        {
            unsigned version = 0;
            auto value = aTsvPalette.substr(keyEnd + 1, valueEnd - keyEnd - 1);
            if (!StringToInteger(value, version))
            {
                throw LoadFailedException("Invalid FileVersion value");
            }
            else if (version != 1)
            {
                throw LoadFailedException(fmt::format(FMT_STRING("Unknown FileVersion: {}. Only version 1 is supported."), version));
            }
            hasHadVersion = true;
        }
        else if (key == "CommonPrefix")
        {
            commonPrefix = aTsvPalette.substr(keyEnd + 1, valueEnd - keyEnd - 1);
        }
        idx = valueEnd;
        if (aTsvPalette[idx] == '\r')  // CR of the CRLF pair, skip the LF:
        {
            ++idx;
        }
        ++line;
    }
    if (!hasHadVersion)
    {
        throw LoadFailedException("No FileVersion value");
    }
 
    // Parse the data:
    while (idx + 1 < len)
    {
        auto lineStart = idx + 1;
        auto idEnd = findNextSeparator(aTsvPalette, lineStart);
        if ((idEnd == AString::npos) || (aTsvPalette[idEnd] != '\t'))
        {
            throw LoadFailedException(fmt::format(FMT_STRING("Incomplete data on line {} (id)"), line));
        }
        UInt32 id;
        if (!StringToInteger(aTsvPalette.substr(lineStart, idEnd - lineStart), id))
        {
            throw LoadFailedException(fmt::format(FMT_STRING("Failed to parse id on line {}"), line));
        }
        size_t metaEnd = idEnd;
        if (isUpgrade)
        {
            metaEnd = findNextSeparator(aTsvPalette, idEnd + 1);
            if ((metaEnd == AString::npos) || (aTsvPalette[metaEnd] != '\t'))
            {
                throw LoadFailedException(fmt::format(FMT_STRING("Incomplete data on line {} (meta)"), line));
            }
            UInt32 meta = 0;
            if (!StringToInteger(aTsvPalette.substr(idEnd + 1, metaEnd - idEnd - 1), meta))
            {
                throw LoadFailedException(fmt::format(FMT_STRING("Failed to parse meta on line {}"), line));
            }
            if (meta > 15)
            {
                throw LoadFailedException(fmt::format(FMT_STRING("Invalid meta value on line {}: {}"), line, meta));
            }
            id = (id * 16) | meta;
        }
        auto blockTypeEnd = findNextSeparator(aTsvPalette, metaEnd + 1);
        if (blockTypeEnd == AString::npos)
        {
            throw LoadFailedException(fmt::format(FMT_STRING("Incomplete data on line {} (blockTypeName)"), line));
        }
        auto blockTypeName = aTsvPalette.substr(metaEnd + 1, blockTypeEnd - metaEnd - 1);
        auto blockStateEnd = blockTypeEnd;
        AStringMap blockState;
        while (aTsvPalette[blockStateEnd] == '\t')
        {
            auto keyEnd = findNextSeparator(aTsvPalette, blockStateEnd + 1);
            if ((keyEnd == AString::npos) || (aTsvPalette[keyEnd] != '\t'))
            {
                throw LoadFailedException(fmt::format(FMT_STRING("Incomplete data on line {} (blockState key)"), line));
            }
            auto valueEnd = findNextSeparator(aTsvPalette, keyEnd + 1);
            if (valueEnd == AString::npos)
            {
                throw LoadFailedException(fmt::format(FMT_STRING("Incomplete data on line {} (blockState value)"), line));
            }
            auto key = aTsvPalette.substr(blockStateEnd + 1, keyEnd - blockStateEnd - 1);
            auto value = aTsvPalette.substr(keyEnd + 1, valueEnd - keyEnd - 1);
            blockState[key] = value;
            blockStateEnd = valueEnd;
        }
        addMapping(id, commonPrefix + blockTypeName, std::move(blockState));
        ++line;
        if (aTsvPalette[blockStateEnd] == '\r')  // CR of the CRLF pair, skip the LF:
        {
            ++blockStateEnd;
        }
        idx = blockStateEnd;
    }
}
 
 
 
 
 
void BlockTypePalette::addMapping(UInt32 aID, const AString & aBlockTypeName, const BlockState & aBlockState)
{
    mNumberToBlock[aID] = {aBlockTypeName, aBlockState};
    mBlockToNumber[aBlockTypeName][aBlockState] = aID;
    if (aID > mMaxIndex)
    {
        mMaxIndex = aID;
    }
}