Method InitController

view/sharedcache/core/SharedCacheView.cpp:803–962

}

bool SharedCacheView::InitController()
{
	auto primaryFilePath = GetPrimaryFilePath();
	if (!primaryFilePath.has_value())
	{
		m_logger->LogError("Failed to get primary file path!");
		return false;
	}
	std::string primaryFileDir = std::filesystem::path(*primaryFilePath).parent_path().string();

	// Get the primary project file from the current files project.
	// This is required to allow selecting a primary file in a different directory. Otherwise, we search the current database directory.
	Ref<ProjectFile> primaryProjectFile = nullptr;
	auto currentProjectFile = GetFile()->GetProjectFile();
	if (currentProjectFile)
		primaryProjectFile = currentProjectFile->GetProject()->GetFileByPathOnDisk(*primaryFilePath);

	if (!IsSameFolderForFile(primaryProjectFile, currentProjectFile))
	{
		// TODO: Remove this restriction using stored cache UUID's and a fast project file search.
		m_logger->LogWarn("Because the primary file is in a different project folder you will need to select it on every open, consider moving the database file into the same folder.");
	}

	// OK, we have the primary shared cache file, now let's add the entries.
	auto sharedCacheBuilder = SharedCacheBuilder(this);
	sharedCacheBuilder.SetPrimaryFileName(m_primaryFileName);

	// Add the primary file. If we fail log alert that the primary cache file is invalid.
	// We process the primary cache entry first as it might be consulted in the processing of later entries.
	if (!sharedCacheBuilder.AddFile(*primaryFilePath, m_primaryFileName, CacheEntryType::Primary))
	{
		m_logger->LogAlertF("Failed to add primary cache file: '{}'", m_primaryFileName);
		return false;
	}

	{
		// After this we should have all the mappings available as well.
		auto startTime = std::chrono::high_resolution_clock::now();
		sharedCacheBuilder.AddDirectory(primaryFileDir);
		if (primaryProjectFile)
			sharedCacheBuilder.AddProjectFolder(primaryProjectFile->GetFolder());
		auto totalEntries = sharedCacheBuilder.GetCache().GetEntries().size();
		auto endTime = std::chrono::high_resolution_clock::now();
		std::chrono::duration<double> elapsed = endTime - startTime;
		m_logger->LogInfo("Processing %zu entries took %.3f seconds", totalEntries, elapsed.count());

		// If we can't store all of our files for this cache in the accessor cache we might run into issues, warn the user.
		if (totalEntries > FileAccessorCache::Global().GetCacheSize())
			m_logger->LogWarn("Cache contains more entries than the allowed number of opened file handles, this may impact reliability.");

		// Verify that we are not missing any entries that were stored in the metadata.
		// If we are that means we should alert the user that a previously associated cache entry is missing.
		std::set<std::string> missingCacheEntries = m_secondaryFileNames;
		uint64_t expectedFileCount = 1;
		for (const auto& entry : sharedCacheBuilder.GetCache().GetEntries())
		{
			missingCacheEntries.erase(entry.GetFileName());
			LogSecondaryFileName(entry.GetFileName());