SystemContainer.hpp

Go to the documentation of this file.

#pragma once
 
#include "../DebugView/TextDebugView.hpp"
#include "../Basics/SrcInfo.hpp"
#include "../Basics/static_warning.hpp"
 
#include <unordered_map>
#include <unordered_set>
#include <iostream>
#include <typeinfo>
#include <typeindex>
#include <csignal>
 
namespace iv
{
 
class SystemContainer;
class TextDebugView;
 
class System : public Context
{
public:
                                System( SystemContainer * sc );
    virtual                     ~System(){}
    
    virtual bool                flushSystem(){ return false; }
    virtual void                status( TextDebugView * view ){}
    virtual std::string         debug_name() const{ return ""; }
    
    SystemContainer *           system_container() const;
    
    void                        retain();
    void                        release();
    
protected:
    virtual bool                log_process_enabled( LogId id ) const override final;
    virtual void                log_process( SrcInfo const & info, LogId id, std::string const & message ) const override final;
    
private:
    SystemContainer * sc;
    unsigned _refcounters;
};
 
class SystemContainer
{
public:
                                SystemContainer();
                                
                                SystemContainer( SystemContainer const * sc );
                                
                                ~SystemContainer();
    
    void                        debug_print( TextDebugView * view ) const;
    
    std::unordered_map< std::type_index /*type*/, System * > const & debug_GetSystems() const;
    
    bool                        flushSystems();
    
    void                        nextFrame();
    
    unsigned                    frame_id() const;
    
    template< class TypedSystem >
    TypedSystem *               getSystem() const;
    
    System *                    getSystem( std::type_index type ) const;
    
    template< class TypedSystem, typename... Args >
    TypedSystem *               createOwnSystem( Args... constructor_arguments );
    
    template< class TypedSystem >
    TypedSystem *               addForeignSystem( TypedSystem * system  );
    
    template< class TypedSystem >
    void                        removeSystem();
    
private:
    std::unordered_map< std::type_index /*type*/, System * > systems;
    std::unordered_set< System * > own_systems;
    unsigned _frame_id;
};
}