Method importTitleListCache

3ds/source/loader.cpp:238–315

}

void TitleCatalog::importTitleListCache(std::vector<Title>& saves, std::vector<Title>& extdatas, IconStore& icons)
{
    FSStream inputsaves(Archive::sdmc(), saveCachePath, FS_OPEN_READ);
    u32 bytesSaves = inputsaves.size();
    std::unique_ptr<u8[]> cachesaves(new u8[bytesSaves]);
    u32 readSaves = inputsaves.read(cachesaves.get(), bytesSaves);
    inputsaves.close();
    // A cache whose size isn't a whole number of entries, or that read short, is
    // corrupt: treat it as empty rather than decoding desynced/garbage entries.
    u32 sizesaves = (bytesSaves % TitleCache::ENTRY_SIZE == 0 && readSaves == bytesSaves) ? bytesSaves / TitleCache::ENTRY_SIZE : 0;

    FSStream inputextdatas(Archive::sdmc(), extdataCachePath, FS_OPEN_READ);
    u32 bytesExtdatas = inputextdatas.size();
    std::unique_ptr<u8[]> cacheextdatas(new u8[bytesExtdatas]);
    u32 readExtdatas = inputextdatas.read(cacheextdatas.get(), bytesExtdatas);
    inputextdatas.close();
    u32 sizeextdatas = (bytesExtdatas % TitleCache::ENTRY_SIZE == 0 && readExtdatas == bytesExtdatas) ? bytesExtdatas / TitleCache::ENTRY_SIZE : 0;

    mLimit = sizesaves + sizeextdatas;

    saves.reserve(sizesaves);
    extdatas.reserve(sizeextdatas);

    // fill the lists with blank titles first
    for (size_t i = 0, sz = std::max(sizesaves, sizeextdatas); i < sz; i++) {
        Title title;
        title.load();
        if (i < sizesaves) {
            saves.push_back(title);
        }
        if (i < sizeextdatas) {
            extdatas.push_back(title);
        }
    }

    // Map each already-loaded save id to its first and last index in `saves`, so
    // the extdata pass can reuse a decoded save (they share entries) with an O(1)
    // lookup instead of a linear scan per extdata — this runs on the startup fast
    // path. Duplicate ids only occur for the cartridge title, hence tracking both
    // ends (see the i != 0 && first == 0 case below).
    std::unordered_map<u64, size_t> firstIdx;
    std::unordered_map<u64, size_t> lastIdx;
    firstIdx.reserve(sizesaves);
    lastIdx.reserve(sizesaves);

    for (size_t i = 0; i < sizesaves; i++) {
        const u8* titleData = cachesaves.get() + i * TitleCache::ENTRY_SIZE;
        saves.at(i)         = TitleCache::decode(titleData, icons);
        u64 id              = TitleCache::readId(titleData);
        firstIdx.emplace(id, i); // keeps the first occurrence
        lastIdx[id] = i;         // always the latest occurrence

        mCounter++;
    }

    for (size_t i = 0; i < sizeextdatas; i++) {
        const u8* titleData = cacheextdatas.get() + i * TitleCache::ENTRY_SIZE;