Container.hpp

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
#include <unordered_map>
#include <thread>
#include <memory>
#include <type_traits>
#include <mutex>
#include <atomic>
#include <functional>
#include <condition_variable>
#include <libecs-cpp/json.hpp>
#include <libecs-cpp/Uuid.hpp>
#include <libecs-cpp/Resource.hpp>
#include <libecs-cpp/Component.hpp>
#include <libecs-cpp/Clock.hpp>
#include <libecs-cpp/Timing.hpp>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <stdexcept>
#include <utility>
 
namespace ecs
{
    class Manager;
    class System;
    class Component;
    class Entity;
    struct Mailbox;
 
    class Container
    {
        friend class Manager;
 
      public:
        Container(ecs::Manager *manager);
        Container(ecs::Manager *manager, const std::string &handle);
        ~Container();
        void Start();
        void Start(std::chrono::microseconds interval);
        void Start(uint32_t);
        void ClockSet(const ecs::Clock *clock);
        void Stop();
        void SystemsInitialize();
        ecs::System *System(std::unique_ptr<ecs::System> system);
        std::shared_ptr<ecs::Component> Component(std::unique_ptr<ecs::Component> component);
        template <class T = ecs::Component>
        std::shared_ptr<T> ComponentGet(const std::string &entity, const std::string &type) const
        {
            const std::shared_ptr<ecs::Component> *found = this->componentFind(entity, type);
            if(found == nullptr)
            {
                return nullptr;
            }
            if constexpr(std::is_same_v<T, ecs::Component>)
            {
                return *found;
            }
            else
            {
                return std::dynamic_pointer_cast<T>(*found);
            }
        }
        bool ComponentHas(const std::string &entity, const std::string &type) const;
        void ComponentDestroy(const std::string &entity, const std::string &type);
        ecs::Entity *Entity(const std::string &handle);
        ecs::Entity *Entity();
        void EntityDestroy(const std::string &handle);
        void SystemDestroy(const std::string &handle);
        nlohmann::json Export() const;
        void Update();
        void MessageSubmit(const nlohmann::json &message);
        void Defer(std::function<void()> fn);
        void ResourceAdd(const std::string &name, ecs::Resource r);
        void Resources(const std::unordered_map<std::string, std::shared_ptr<ecs::Resource>> &resources);
        std::shared_ptr<const ecs::Resource> ResourceGet(const std::string &name) const;
        std::unordered_map<std::string, std::unique_ptr<ecs::Entity>> Entities;
        ecs::Manager *Manager = nullptr;
        const std::string Handle;
        ecs::TypeEntityComponentList Components;
        ecs::Uuid UuidGet();
        std::unordered_map<std::string, std::unique_ptr<ecs::System>> Systems;
        void Log(const std::string &message, const std::string &level = "info");
        void LoggerSet(std::function<void(const std::string &, const std::string &)> fn);
      private:
        std::mutex mailboxesLock;
        std::unordered_map<std::string, std::shared_ptr<ecs::Mailbox>> mailboxes;
        using LogFunction = std::function<void(const std::string &, const std::string &)>;
        std::mutex loggerLock;
        std::shared_ptr<const LogFunction> logger;
        struct SystemSlot
        {
            std::string handle;
            ecs::System *system;
            bool started = false;
            bool shutdown = false;
        };
        class WalkScope;
        std::vector<SystemSlot> systemOrder;
        uint32_t walkDepth = 0;
        std::mutex deferredLock;
        std::vector<std::function<void()>> deferred;
        std::atomic<std::size_t> deferredCount{0};
        bool deferredClosed = false;
        bool draining = false;
        void deferredRun();
        bool orderHasGaps = false;
        void walkFinish();
        struct RetiredSystem
        {
            std::unique_ptr<ecs::System> system;
            bool notify = false;
        };
        std::vector<RetiredSystem> retiredSystems;
        void systemRetire(std::unique_ptr<ecs::System> system, bool notify);
        void systemNotify(ecs::System *system);
        void retiredRelease();
        void deferredClose();
        std::chrono::microseconds sleepInterval = ecs::DEFAULT_INTERVAL;
        const ecs::Clock *clock = &ecs::SteadyClock::Instance();
 
        std::jthread containerThread;
        void threadFunc(std::stop_token stopToken);
        ecs::Entity *entityCreate(const std::string &handle);
        const std::shared_ptr<ecs::Component> *componentFind(const std::string &entity, const std::string &type) const
        {
            auto byType = this->Components.find(type);
            if(byType == this->Components.end())
            {
                return nullptr;
            }
            auto byEntity = byType->second.find(entity);
            if(byEntity == byType->second.end())
            {
                return nullptr;
            }
            return byEntity->second ? &byEntity->second : nullptr;
        }
 
        std::unordered_map<std::string, std::shared_ptr<ecs::Resource>> resources;
 
        bool startPending = false;
        void systemsStart();
        bool tearingDown = false;
        bool tornDown = false;
        void teardown();
 
        std::mutex lifecycleLock;
        std::condition_variable_any lifecycleChanged;
        bool threadStarted = false;
        std::atomic<bool> stopRequested{false};
        bool stopDone = false;
        bool joining = false;
        bool joined = false;
        std::atomic<bool> ownsThread{false};
        void threadStart(const std::chrono::microseconds *interval);
        void requestStop();
        void waitStopped();
        bool managerStopRequest();
        void managerStopWait();
    };
}