Function findAndPreLoadObject

src/OpenLoco/src/Objects/ObjectManager.cpp:423–483

    };

    static std::optional<PreLoadedObject> findAndPreLoadObject(const ObjectHeader& header)
    {
        auto installedObject = findObjectInIndex(header);
        if (!installedObject.has_value())
        {
            return std::nullopt;
        }

        const auto filePath = fs::u8path(installedObject->_filepath);

        FileStream fs(filePath, StreamMode::read);
        SawyerStreamReader stream(fs);
        PreLoadedObject preLoadObj{};
        stream.read(&preLoadObj.header, sizeof(preLoadObj.header));
        if (preLoadObj.header != header)
        {
            // Something wrong has happened and installed object does not match index
            // Vanilla continued to search for subsequent matching installed headers.
            Logging::error("Mismatch between installed object header and object file header!");
            return std::nullopt;
        }

        // Vanilla would branch and perform more efficient readChunk if size was known from installedObject.ObjectHeader2
        std::span<const std::byte> data;
        try
        {
            data = stream.readChunk();
        }
        catch (const Exception::RuntimeError&)
        {
            // Something wrong has happened and installed object checksum is broken
            Logging::error("Data could not be read!");
            return std::nullopt;
        }
        if (!computeObjectChecksum(preLoadObj.header, data))
        {
            // Something wrong has happened and installed object checksum is broken
            Logging::error("Mismatch between installed object header checksum and object file checksum!");
            return std::nullopt;
        }

        // Copy the object into Loco freeable memory (required for when load loads the object)
        preLoadObj.object = reinterpret_cast<Object*>(malloc(data.size()));
        if (preLoadObj.object == nullptr)
        {
            return std::nullopt;
        }
        std::copy(std::begin(data), std::end(data), reinterpret_cast<std::byte*>(preLoadObj.object));

        preLoadObj.objectData = std::span<std::byte>(reinterpret_cast<std::byte*>(preLoadObj.object), data.size());

        if (!callObjectValidate(preLoadObj.header.getType(), *preLoadObj.object))
        {
            free(preLoadObj.object);
            // Object failed validation
            Logging::error("Object {} in index failed validation! (This should not be possible)", header.getName());
            return std::nullopt;
        }