SystemManager.h

Go to the documentation of this file.

/*
* True Reality Open Source Game and Simulation Engine
* Copyright © 2021 Acid Rain Studios LLC
*
* This library is free software; you can redistribute it and/or modify it under
* the terms of the GNU Lesser General Public License as published by the Free
* Software Foundation; either version 3.0 of the License, or (at your option)
* any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this library; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* @author Maxim Serebrennik
*/

#pragma once

#include "Export.h"

#include <trManager/DirectorPriority.h>
#include <trManager/MessageBase.h>
#include <trManager/EntityBase.h>
#include <trUtil/HashMap.h>
#include <trBase/UniqueId.h>
#include <trBase/SmrtPtr.h>
#include <trBase/Base.h>

#include <utility>
#include <string>
#include <vector>
#include <queue>
#include <list>

namespace trManager
{
    class TR_MANAGER_EXPORT SystemManager : public trBase::Base
    {
    public:

        using BaseClass = trBase::Base;                 

        const static trUtil::RefStr CLASS_TYPE;         

        static trManager::SystemManager& GetInstance();

        virtual const std::string& GetType() const override;

        virtual bool SendMessage(const trManager::MessageBase& message);

        virtual bool SendNetworkMessage(const trManager::MessageBase& message);

        virtual void ProcessMessage(const trManager::MessageBase& message);

        virtual void ProcessMessages();

        virtual void ProcessNetworkMessages();

        virtual void RegisterForMessage(const std::string& messageType, EntityBase& listeningActor, const std::string& invokableName);

        virtual void UnregisterFromMessage(const std::string& messageType, EntityBase& listeningActor);

        virtual void RegisterForMessagesAboutEntity(EntityBase& listeningEntity, const trBase::UniqueId& aboutEntityId, const std::string& invokableName);

        virtual void UnregisterFromMessagesAboutEntity(EntityBase& listeningEntity, const trBase::UniqueId& aboutEntityId);

        virtual bool RegisterActor(trManager::EntityBase& actor);

        virtual bool UnregisterActor(trManager::EntityBase& actor);

        virtual bool UnregisterActor(const trBase::UniqueId& id);

        virtual bool UnregisterAllActors();

        virtual trManager::EntityBase* FindActor(const trBase::UniqueId& id);

        virtual std::vector<trManager::EntityBase*> FindActorsByType(const std::string& actorType);

        virtual std::vector<trManager::EntityBase*> FindActorsByName(const std::string& actorName);

        virtual bool RegisterDirector(trManager::EntityBase& director, trManager::DirectorPriority& priority = trManager::DirectorPriority::NORMAL);

        virtual bool UnregisterDirector(trManager::EntityBase& director);

        virtual bool UnregisterDirector(const trBase::UniqueId& id);

        virtual void UnregisterAllDirectors();

        virtual trManager::EntityBase* FindDirector(const trBase::UniqueId& id) const;

        virtual trManager::EntityBase* FindDirector(const std::string& name) const;

        virtual std::vector<trManager::EntityBase*> FindDirectors(const std::string& type) const;

        virtual void RemoveMarkedEntities();

        virtual void ShutDown();

    protected:

        SystemManager(const std::string name = CLASS_TYPE);

        ~SystemManager();

        virtual void SendMessageToDirectors(const trManager::MessageBase& message);

        virtual void SendMessageToActors(const trManager::MessageBase& message);

        virtual void SendMessageToListeners(const trManager::MessageBase& message);

        virtual void SendGlobalyRegisteredMessage(const trManager::MessageBase& message);

        virtual void CallInvokable(const trManager::MessageBase& message, const std::string& invokableName, trManager::EntityBase& entity);

        virtual void UnregisterActorFromGlobalMessages(trManager::EntityBase& actor);

        virtual void UnregisterDirectorFromGlobalMessages(trManager::EntityBase& director);

        virtual void UnregisterEntityFromAboutMessages(trManager::EntityBase& listeningEntity);

    private:

        static trBase::SmrtPtr<trManager::SystemManager> mInstance;
        std::queue<trBase::SmrtPtr<const trManager::MessageBase>> mMessageQueue;
        std::queue<trBase::SmrtPtr<const trManager::MessageBase>> mNetworkMessageQueue;

        // Storage for all the registered Directors
        using DirectorList = std::list<trBase::SmrtPtr<trManager::EntityBase>>;           //Needs to be a std::list so the directors can be priority sorted
        using DirectorNameMap = trUtil::HashMap<std::string, trBase::SmrtPtr<trManager::EntityBase>>;
        using DirectorIDMap = trUtil::HashMap<trBase::UniqueId, trBase::SmrtPtr<trManager::EntityBase>>;
        DirectorList mDirectorList;
        DirectorNameMap mDirectorNameMap;
        DirectorIDMap mDirectorIDMap;

        //Message registration structures..
        using EntityInvokablePair = std::pair<trBase::SmrtPtr<trManager::EntityBase>, std::string>;                     //<entity, invokableName>
        using MessageRegistrationVectorMap = trUtil::HashMap<std::string*, std::vector<EntityInvokablePair>>;     //<messageName, vector of registered entityPairs>
        using UUIDRegistrationVectorMap = trUtil::HashMap<trBase::UniqueId, std::vector<EntityInvokablePair>>;    //<UUID, vector of registered entityPairs>
        using EntityInvokableMap = trUtil::HashMap<trBase::SmrtPtr<trManager::EntityBase>, std::string>;                //<entity, invokableName>
        using MessageRegistrationMap = trUtil::HashMap<std::string*, EntityInvokableMap>;                         //<messageName, <entity, invokableName>>
        MessageRegistrationVectorMap mEntityGlobalMsgRegistrationMap;
        MessageRegistrationMap mDirectorGlobalMsgRegistrationMap;
        UUIDRegistrationVectorMap mListenerRegistrationMap;

        //Storage for all registered Actors and Actor Modules
        using ActorList = std::vector<trBase::SmrtPtr<trManager::EntityBase>>;
        using ActorIDMap = trUtil::HashMap<trBase::UniqueId, trBase::SmrtPtr<trManager::EntityBase>>;
        ActorList mActorList;
        ActorIDMap mActorIDMap;

        std::vector<trBase::SmrtPtr<trManager::EntityBase>> mEntityDeleteList;         //List of entities that will be deleted at the end of the frame

        void RegisterMsgWithMsgVectorMap(const std::string& messageType, EntityBase& listeningEntity, const std::string& invokableName, MessageRegistrationVectorMap& messageMap);

        void UnregisterMsgFromMsgVectorMap(const std::string& messageType, EntityBase& listeningEntity, MessageRegistrationVectorMap& messageMap);

        void RegisterMsgWithMsgMap(const std::string& messageType, EntityBase& listeningEntity, const std::string& invokableName, MessageRegistrationMap& messageMap);

        void UnregisterMsgFromMsgMap(const std::string& messageType, EntityBase& listeningEntity, MessageRegistrationMap& messageMap);
    };
}