Cppcheck report - Fission: libs/fsAppCore/fsIRunningOrder.cpp

#include "fsIRunningOrder.h"

#include <algorithm>
#include <set>

#include <fsCore/fsStr.h>
#include <fsCore/fsIFile.h>
#include <fsCore/fsIResourceNamePathAdjuster.h>
#include <fsCore/src/debug/fsAssert.h>
#include <fsCore/src/fsCAppSettings.h>

#include "fsCRunningOrderGrammar.h"
#include "src/fsCAppCoreMain.h"
#include "src/components/gui/fsCLocaleOptions.h"
#include "src/components/gui/fsIGuiComponent.h"
#include "src/fsILevelBasedAppCoreMain.h"

const fsStr fsIRunningOrder::mMapDestinationPrefix("map->");

void fsIRunningOrder::replace(const std::vector<fsStr>& pNewOrder)
{
	replaceDo(pNewOrder);
}

fsS32 fsIRunningOrder::levelCountGet() const
{
	return mSequence.size();
}

fsS32 fsIRunningOrder::currLevelPosGet() const
{
	return currentLevelIteratorGet(mCurrentLocation) - mSequence.begin();
}

const fsStr& fsIRunningOrder::firstLocationGet() const
{
	return mSequence.front();
}

void fsIRunningOrder::nextLocationClear()
{
	mCurrentLocation = mNextLocation;
	mNextLocation = "";
}

fsBool fsIRunningOrder::nextLocationReady() const
{
	return !nextLocationGet().emptyGet();
}

fsStr fsIRunningOrder::nextLocationGet(const fsStr& pCurrentLocation) const
{
	return nextLocationGetDo(pCurrentLocation);
}

fsStr fsIRunningOrder::nextLocationGetDo(const fsStr& pCurrentLocation) const
{
	fsStr location = pCurrentLocation;
#if defined fsDownCaseFilename
	location.downcase();
#endif
	auto curr = currentLevelIteratorGet(location);
	++curr;

	fsStr nextLev = *curr;
	return nextLev;
}

std::vector<fsStr>::const_iterator fsIRunningOrder::currentLevelIteratorGet(const fsStr& pCurrentLocation) const
{
	return currentLevelIteratorGetDo(pCurrentLocation);
}

std::vector<fsStr>::const_iterator fsIRunningOrder::currentLevelIteratorGetDo(const fsStr& pCurrentLocation) const
{
	return std::find_if(
		mSequence.begin(), mSequence.end(),
		[&](const fsStr lev)
		{
			return pCurrentLocation == lev;
		});
}

void fsIRunningOrder::levelCompleteSet()
{
	if (mNextLocation.emptyGet())
	{
		auto curr = currentLevelIteratorGet(mCurrentLocation);
		++curr;
		mCurrentLocation = *curr;
		nextLocationSet(mCurrentLocation);
	}
}

void fsIRunningOrder::singleLevel()
{
	mCurrentLocation = mNextLocation;
}

void fsIRunningOrder::gameContinue()
{
	gameContinueDo();
}

void fsIRunningOrder::newGameStart()
{
	newGameStartDo();
}

void fsIRunningOrder::newGameStartDo()
{
	nextLocationSet(mSequence.front());
	mCurrentLocation = mNextLocation;
}

const fsStr& fsIRunningOrder::nextLocationGet() const
{
	return mNextLocation;
}

void fsIRunningOrder::nextLocationSet(const fsStr& pNextLocation)
{
	nextLocationSetDo(pNextLocation);
}

void fsIRunningOrder::nextLocationSetDo(const fsStr& pNextLocation)
{
	mNextLocation = pNextLocation;
}

fsBool fsIRunningOrder::loopsCheck() const
{
	std::set<fsStr> loops(mSequence.begin(), mSequence.end());
	return mSequence.size() != loops.size();
}

void fsIRunningOrder::sequenceCheck()
{
	sequenceCheckDo();
	mHasLoops = loopsCheck();
	fsAssert(!mHasLoops, "Running order has loops");
}

void fsIRunningOrder::sequenceCheckDo() const
{
	std::for_each(mSequence.begin(), mSequence.end(),
	              [](fsStr level)
	              {
		              fsAssert(
			              fsIFile::fileExistsGet(fsCResourceName(
								fsILevelBasedAppCoreMain::scenesFolderGet()
								+ fsIResourceNamePathAdjuster::mPathSeparator
								+ level
								+ fsIResourceNamePathAdjuster::mPathSeparator
								+ level
								+ ".txt",
				              fsCResourceName::eRES_LOCATION_ASSETS)),
			              "runningOrder broken, no such level: %s", level.utf8Get());
	              });
}

const VarTableMap* fsIRunningOrder::resolvedSceneConfigGet(const fsStr& pSceneName) const
{
	const auto found = mResolvedConfigs.find(pSceneName);
	return found == mResolvedConfigs.end() ? nullptr : &found->second;
}

void fsIRunningOrder::guiSequenceLoad(const fsCResourceName& pResolvedFile, fsBool pMapNavigationUsed)
{
	const fsStr text = fsIFile::strGetFromFile(pResolvedFile);

	const fsStr flavour =
		fsCAppCoreMain::instanceGet()->settingsGet()->buildFlavourGet() == "CE" ? "collectors" : "standard";
	const fsStr language = fsCAppCoreMain::instanceGet()->localeGet()->localeCodeGet();

	const std::vector<fsCRunningOrderGrammar::ResolvedScene> resolved =
		fsCRunningOrderGrammar::resolve(text, flavour, language);

	for (const fsCRunningOrderGrammar::ResolvedScene& scene : resolved)
	{
		// Reproduce the legacy list: bare scene name, re-adding the map->
		// prefix only for HOG map-first scenes so the subclass's existing
		// full-path/navigation code sees exactly what runningOrder.txt gave it.
		const fsBool mapFirst = pMapNavigationUsed && scene.mGoesToMap;
		mSequence.push_back(mapFirst ? mMapDestinationPrefix + scene.mName : scene.mName);
		mResolvedConfigs[scene.mName] = scene.mConfig;
	}
}

fsIRunningOrder::fsIRunningOrder(const fsCResourceName& pFilename, fsBool pMapNavigationUsed):
	mNextLocation("")
{
	// Extension dispatch, reusing the GUI resolver: runningOrder.gui present ->
	// parse+resolve+filter; otherwise the legacy bare-list read.
	fsStr resolvedName;
	mGuiMode = fsIGuiComponent::newGrammarFileNameResolve(pFilename.nameGet(), resolvedName);
<--- Variable 'mGuiMode' is assigned in constructor body. Consider performing initialization in initialization list. [+]
When an object of a class is created, the constructors of all member variables are called consecutively in the order the variables are declared, even if you don't explicitly write them to the initialization list. You could avoid assigning 'mGuiMode' a value by passing the value to the constructor in the initialization list.
	if (mGuiMode)
	{
		guiSequenceLoad(fsCResourceName(resolvedName, pFilename.locationGet()), pMapNavigationUsed);
		return;
	}

	fsStr levelSequence = fsIFile::strGetFromFile(pFilename);
	fsStr level = levelSequence.chomp("\n");
	while (!level.emptyGet())
	{
		mSequence.push_back(level);
		level = levelSequence.chomp("\n");
	}
}

fsIRunningOrder::~fsIRunningOrder()
{
}