metaforce/DataSpec/DNACommon/DNACommon.cpp

#include "DNACommon.hpp"
#include "PAK.hpp"
#include "boo/ThreadLocalPtr.hpp"

namespace DataSpec
{

logvisor::Module LogDNACommon("urde::DNACommon");
ThreadLocalPtr<SpecBase> g_curSpec;
ThreadLocalPtr<PAKRouterBase> g_PakRouter;
ThreadLocalPtr<hecl::Database::Project> UniqueIDBridge::s_Project;
UniqueID32 UniqueID32::kInvalidId;

template <class IDType>
hecl::ProjectPath UniqueIDBridge::TranslatePakIdToPath(const IDType& id, bool silenceWarnings)
{
    /* Try PAKRouter first (only available at extract) */
    PAKRouterBase* pakRouter = g_PakRouter.get();
    if (pakRouter)
    {
        hecl::ProjectPath path = pakRouter->getWorking(id, silenceWarnings);
        if (path)
            return path;
    }

    /* Try project cache second (populated with paths read from YAML resources) */
    hecl::Database::Project* project = s_Project.get();
    if (!project)
    {
        if (pakRouter)
        {
            if (!silenceWarnings)
                LogDNACommon.report(logvisor::Warning,
                                    "unable to translate %s to path", id.toString().c_str());
            return {};
        }
        LogDNACommon.report(logvisor::Fatal,
        "g_PakRouter or s_Project must be set to non-null before "
        "calling UniqueIDBridge::TranslatePakIdToPath");
    }

    const hecl::ProjectPath* search = project->lookupBridgePath(id.toUint64());
    if (!search)
    {
        if (!silenceWarnings)
            LogDNACommon.report(logvisor::Warning,
                                "unable to translate %s to path", id.toString().c_str());
        return {};
    }
    return *search;
}
template
hecl::ProjectPath UniqueIDBridge::TranslatePakIdToPath(const UniqueID32& id, bool silenceWarnings);
template
hecl::ProjectPath UniqueIDBridge::TranslatePakIdToPath(const UniqueID64& id, bool silenceWarnings);

template <class IDType>
hecl::ProjectPath UniqueIDBridge::MakePathFromString(const std::string& str)
{
    if (str.empty())
        return {};
    hecl::Database::Project* project = s_Project.get();
    if (!project)
        LogDNACommon.report(logvisor::Fatal,
                            "UniqueIDBridge::setGlobalProject must be called before MakePathFromString");
    hecl::ProjectPath path = hecl::ProjectPath(*project, str);
    project->addBridgePathToCache(IDType(path).toUint64(), path);
    return path;
}
template
hecl::ProjectPath UniqueIDBridge::MakePathFromString<UniqueID32>(const std::string& str);
template
hecl::ProjectPath UniqueIDBridge::MakePathFromString<UniqueID64>(const std::string& str);

template <class IDType>
void UniqueIDBridge::TransformOldHashToNewHash(IDType& id)
{
    id = TranslatePakIdToPath(id);
}
template
void UniqueIDBridge::TransformOldHashToNewHash(UniqueID32& id);
template
void UniqueIDBridge::TransformOldHashToNewHash(UniqueID64& id);

void UniqueIDBridge::setThreadProject(hecl::Database::Project& project)
{
    s_Project.reset(&project);
}

/** PAK 32-bit Unique ID */
void UniqueID32::read(athena::io::IStreamReader& reader)
{m_id = reader.readUint32Big();}
void UniqueID32::write(athena::io::IStreamWriter& writer) const
{writer.writeUint32Big(m_id);}
void UniqueID32::read(athena::io::YAMLDocReader& reader)
{
    *this = UniqueIDBridge::MakePathFromString<UniqueID32>(reader.readString(nullptr));
}
void UniqueID32::write(athena::io::YAMLDocWriter& writer) const
{
    if (!operator bool())
        return;
    hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath(*this);
    if (!path)
        return;
    writer.writeString(nullptr, path.getAuxInfo().size() ?
        (path.getRelativePathUTF8() + '|' + path.getAuxInfoUTF8()) :
         path.getRelativePathUTF8());
}
size_t UniqueID32::binarySize(size_t __isz) const
{return __isz + 4;}

std::string UniqueID32::toString() const
{
    char buf[9];
    snprintf(buf, 9, "%08X", m_id);
    return std::string(buf);
}

AuxiliaryID32& AuxiliaryID32::operator=(const hecl::ProjectPath& path)
{
    m_id = path.ensureAuxInfo(m_auxStr).hash().val32();
    return *this;
}

AuxiliaryID32& AuxiliaryID32::operator=(const UniqueID32& id)
{
    m_baseId = id;
    hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath(id);
    if (path)
    {
        if (m_addExtension)
            path = path.getWithExtension(m_addExtension);
        *this = path;
    }
    return *this;
}

void AuxiliaryID32::read(athena::io::IStreamReader& reader)
{
    m_id = reader.readUint32Big();
    m_baseId = *this;
}

void AuxiliaryID32::write(athena::io::IStreamWriter& writer) const
{
    writer.writeUint32Big(m_id);
}

void AuxiliaryID32::read(athena::io::YAMLDocReader& reader)
{
    hecl::ProjectPath readPath = UniqueIDBridge::MakePathFromString<UniqueID32>(reader.readString(nullptr));
    *this = readPath.ensureAuxInfo(m_auxStr);
}

void AuxiliaryID32::write(athena::io::YAMLDocWriter& writer) const
{
    if (!operator bool())
        return;
    hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath(*this, true);
    if (!path)
        path = UniqueIDBridge::TranslatePakIdToPath(m_baseId);
    if (!path)
        return;
    if (m_addExtension)
        path = path.getWithExtension(m_addExtension);
    hecl::SystemUTF8View ufx8AuxStr(m_auxStr);
    writer.writeString(nullptr, path.getRelativePathUTF8() + '|' + ufx8AuxStr);
}


/** PAK 64-bit Unique ID */
void UniqueID64::read(athena::io::IStreamReader& reader)
{m_id = reader.readUint64Big();}
void UniqueID64::write(athena::io::IStreamWriter& writer) const
{writer.writeUint64Big(m_id);}
void UniqueID64::read(athena::io::YAMLDocReader& reader)
{
    *this = UniqueIDBridge::MakePathFromString<UniqueID64>(reader.readString(nullptr));
}
void UniqueID64::write(athena::io::YAMLDocWriter& writer) const
{
    if (!operator bool())
        return;
    hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath(*this);
    if (!path)
        return;
    writer.writeString(nullptr, path.getAuxInfo().size() ?
        (path.getRelativePathUTF8() + '|' + path.getAuxInfoUTF8()) :
         path.getRelativePathUTF8());
}
size_t UniqueID64::binarySize(size_t __isz) const
{return __isz + 8;}

std::string UniqueID64::toString() const
{
    char buf[17];
    snprintf(buf, 17, "%016" PRIX64, m_id);
    return std::string(buf);
}

/** PAK 128-bit Unique ID */
void UniqueID128::read(athena::io::IStreamReader& reader)
{
    m_id[0] = reader.readUint64Big();
    m_id[1] = reader.readUint64Big();
}
void UniqueID128::write(athena::io::IStreamWriter& writer) const
{
    writer.writeUint64Big(m_id[0]);
    writer.writeUint64Big(m_id[1]);
}
void UniqueID128::read(athena::io::YAMLDocReader& reader)
{
    *this = UniqueIDBridge::MakePathFromString<UniqueID128>(reader.readString(nullptr));
}
void UniqueID128::write(athena::io::YAMLDocWriter& writer) const
{
    if (!operator bool())
        return;
    hecl::ProjectPath path = UniqueIDBridge::TranslatePakIdToPath(*this);
    if (!path)
        return;
    writer.writeString(nullptr, path.getAuxInfo().size() ?
        (path.getRelativePathUTF8() + '|' + path.getAuxInfoUTF8()) :
         path.getRelativePathUTF8());
}
size_t UniqueID128::binarySize(size_t __isz) const
{return __isz + 16;}

std::string UniqueID128::toString() const
{
    char buf[33];
    snprintf(buf, 33, "%016" PRIX64 "%016" PRIX64, m_id[0], m_id[1]);
    return std::string(buf);
}


/** Word Bitmap reader/writer */
void WordBitmap::read(athena::io::IStreamReader& reader, size_t bitCount)
{
    m_bitCount = bitCount;
    size_t wordCount = (bitCount + 31) / 32;
    m_words.clear();
    m_words.reserve(wordCount);
    for (size_t w=0 ; w<wordCount ; ++w)
        m_words.push_back(reader.readUint32Big());
}
void WordBitmap::write(athena::io::IStreamWriter& writer) const
{
    for (atUint32 word : m_words)
        writer.writeUint32Big(word);
}
size_t WordBitmap::binarySize(size_t __isz) const
{
    return __isz + m_words.size() * 4;
}

}