Cppcheck report - Fission: libs/fsAppCore/src/fsCEntity.h

/********************************************************************
*
*	File:		fsCEntity.h
*
*	Purpose:	Core container for components.
*
*				Interface components via fsCUniqueId which is also
*				handily wrapped up using templates to make the client
*				code cleaner.
*
*				Based on fsCUniqueId so you can't remove the interface
*				to it!
*
*********************************************************************/

#ifndef fsCEntityhdr
#define fsCEntityhdr

#include <typeinfo>
#include <map>
#include <vector>
#include <algorithm>
#include <memory>


#include "../fsINode.h"

class fsIComponent;
class fsCUniqueId;
class fsIRenderableComponent;
class fsISpriteComponent;
class fsIScene;
class fsITextSpriteComponent;
class fsCComponentFactory;
class fsCEntityFactory;
class fsCTaggableComponent;

class fsCEntity : public fsINode
{
	friend class fsCEntityFactory;
	friend class gfCTestLoadGuis;
	friend class fsIGuiComponent;

public:
  fsCEntity *grandparentGet() const;

	void listenersRegister();
	void listenersDeRegister();

	static void componentFactorySet(std::shared_ptr<fsCComponentFactory> pComponentFactory);
        fsCComponentFactory *componentFactoryGet();
	static void entityFactorySet(std::shared_ptr<fsCEntityFactory> pEntityFactory);
        fsCEntityFactory *entityFactoryGet();

        fsITextSpriteComponent *textComponentGet() const;
        fsITextSpriteComponent *textComponentAdd();

        fsISpriteComponent *spriteComponentGet() const;
        fsISpriteComponent *spriteComponentAdd();

	fsBool tagExists(fsStr const& pTag) const;
	void tagAdd(fsStr const& pTag);

	template <typename TComponent>
	TComponent* componentAdd();<--- The member function 'fsCEntity::componentAdd < fsCBarGuiComponent >' can be static.<--- The member function 'fsCEntity::componentAdd < fsCTaggableComponent >' can be static.<--- The member function 'fsCEntity::componentAdd < fsCTextSpriteComponent >' can be static.<--- The member function 'fsCEntity::componentAdd < fsCSpriteComponent >' can be static.
        fsIComponent *componentAdd(const fsCUniqueId& pTypeId);

	template <typename TComponent>
	TComponent* componentGet() const;<--- The member function 'fsCEntity::componentGet < fsCTaggableComponent >' can be static.
        fsIComponent *componentGet(const fsCUniqueId& pTypeId) const;

	void componentDestroy(const fsCUniqueId& pTypeId);

	template <typename TInterface>
	TInterface* firstComponentOfFamilyType() const;

	template <typename TLamda>
	void forMyChildren(TLamda&& pLamda);
	template <typename TLamda>
	void forAllChildren(TLamda&& pLamda);

	fsCEntity* childFind(const fsStr& pName, fsBool pCaseless = false);

	template <typename TInterface>
	std::vector<TInterface*> componentsOfFamilyTypeGet() const;
	template <typename TInterface>
	std::vector<fsCEntity*> childEntitiesWithComponentsOfFamilyType();
	std::vector<fsCEntity*> childEntitiesWithComponentsOfTypeGet(
		const std::vector<const std::type_info*>& pPossibleComponentTypes);
	std::vector<fsCEntity*> childEntitiesTaggedWithGet(std::vector<fsStr> pTags);

	template <typename TInterface>
        fsCEntity *firstChildEntityWithComponentsOfFamilyType();

protected:

	fsCEntity(const fsStr& pName);
	virtual ~fsCEntity();<--- Destructor in derived class

	void initialiseFromVariableTableDo(const fsCVariableTable& pVars) override;

	void updateDo(fsS32 pDeltaMs) override;
	void renderDo() override;
	void updatedMatrixProcess() override;

	void initDo() override;
	void resetDo() override;
	void serialiseDo() override;
	void deserialiseDo() override;
	void postLoad() override;
	void postLinkDo() override;

private:


	void componentUpdateMethodExecute(void (fsIComponent::*pMethod)());

	void deferredComponentsAdd();
	void deferredComponentsRemove();

	void componentUnregisterAndDestroy(const fsCUniqueId& pTypeId);

	void childEntitiesWithComponentsOfTypeGetDo(std::vector<fsCEntity*>& pVectorToFill,
	                                            const std::vector<const std::type_info*>& pPossibleComponentTypes);
	void childEntitiesTaggedWithGetDo(std::vector<fsStr> pTags, std::vector<fsCEntity*>& pEnts);

	std::map<fsU32, fsIComponent*> mComponentsMap;
	std::vector<fsIComponent*> mComponentsVector;

	std::vector<std::pair<fsIComponent*, fsU32>> mComponentsToAdd;
	std::vector<fsCUniqueId> mComponentsToDestroy;

	fsBool mInComponentUpdate;

	static std::shared_ptr<fsCEntityFactory> mEntityFactory;
	static std::shared_ptr<fsCComponentFactory> mComponentFactory;
};


template <typename TInterface>
TInterface* fsCEntity::firstComponentOfFamilyType() const
{
	for (auto iter = mComponentsMap.begin(); iter != mComponentsMap.end(); ++iter)
	{
		if (auto* result = dynamic_cast<TInterface*>(iter->second))
		{<--- Consider using std::any_of algorithm instead of a raw loop.
			return result;
		}
	}

	for (auto iter = mComponentsToAdd.begin(); iter != mComponentsToAdd.end(); ++iter)
	{
		if (auto* result = dynamic_cast<TInterface*>(iter->first))
		{<--- Consider using std::any_of algorithm instead of a raw loop.
			return result;
		}
	}
	return nullptr;
}

template <typename TInterface>
std::vector<TInterface*> fsCEntity::componentsOfFamilyTypeGet() const
{
	std::vector<TInterface*> comps;
	for (auto iter = mComponentsMap.begin(); iter != mComponentsMap.end(); ++iter)
	{
		if (auto* result = dynamic_cast<TInterface*>(iter->second))
		{
			comps.push_back(result);
		}
	}

	for (auto compIt = mComponentsToAdd.begin(); compIt != mComponentsToAdd.end(); ++compIt)
	{
		if (auto* result = dynamic_cast<TInterface*>(compIt->first))
		{
			comps.push_back(result);
		}
	}
	return comps;
}


template <typename TInterface>
std::vector<fsCEntity*> fsCEntity::childEntitiesWithComponentsOfFamilyType()
{
	std::vector<fsCEntity*> ents;

	for (fsINode* child : mChildren)
	{
		if (fsCEntity* childEnt = dynamic_cast<fsCEntity*>(child))
		{
			auto ret = childEnt->childEntitiesWithComponentsOfFamilyType<TInterface>();
			ents.insert(ents.end(), ret.begin(), ret.end());
		}
	}

	for (auto iter = mComponentsMap.begin(); iter != mComponentsMap.end(); ++iter)
	{
		if (dynamic_cast<TInterface*>(iter->second))
		{
			ents.push_back(this);
		}
	}
	return ents;
}

template <typename TComponent>
TComponent* fsCEntity::componentGet() const<--- The member function 'fsCEntity::componentGet < fsCTaggableComponent >' can be static.
{
	return dynamic_cast<TComponent* const>(componentGet(TComponent::mTypeId));
}

template <typename TComponent>
TComponent* fsCEntity::componentAdd()<--- The member function 'fsCEntity::componentAdd < fsCBarGuiComponent >' can be static.<--- The member function 'fsCEntity::componentAdd < fsCTaggableComponent >' can be static.<--- The member function 'fsCEntity::componentAdd < fsCTextSpriteComponent >' can be static.<--- The member function 'fsCEntity::componentAdd < fsCSpriteComponent >' can be static.
{
	return dynamic_cast<TComponent* const>(componentAdd(TComponent::mTypeId));
}

template <typename TInterface>
fsCEntity *fsCEntity::firstChildEntityWithComponentsOfFamilyType()
{
	for (fsINode* child : mChildren)
	{
		if (fsCEntity* childEnt = dynamic_cast<fsCEntity*>(child))
		{
			if (auto matchEnt = childEnt->firstChildEntityWithComponentsOfFamilyType<TInterface>())
			{
				return matchEnt;
			}
		}
	}

	for (auto component : mComponentsMap)
	{
		if (dynamic_cast<TInterface*>(component.second))
		{<--- Consider using std::any_of algorithm instead of a raw loop.
			return this;
		}
	}
	return nullptr;
}

template <typename TLamda>
void fsCEntity::forAllChildren(TLamda&& pLamda)
{
	std::for_each(mChildren.begin(), mChildren.end(),
	              [&pLamda](fsINode* node)
	              {
		              if (fsCEntity* const ent = dynamic_cast<fsCEntity*>(node))
		              {
			              ent->forAllChildren(pLamda);
		              }
	              });
	pLamda(this);
}

template <typename TLamda>
void fsCEntity::forMyChildren(TLamda&& pLamda)
{
	std::for_each(mChildren.begin(), mChildren.end(), pLamda);
}

#endif