Compile-Time recursion

#include <SFML/System.hpp>

template <typename T>
struct SingleUpdater {
    T& system;
    sf::Time total;

    SingleUpdater(T& system)
        : system{system}
        , total{sf::Time::Zero} {
    }

    void update(sf::Time const & elapsed) {
        sf::Clock clock;
        system.update(elapsed);
        total += clock.restart();
    }
};

template <typename... Tail>
struct MultiUpdater;

template <typename Head, typename... Tail>
struct MultiUpdater<Head, Tail...>
    : MultiUpdater<Tail...>
    , SingleUpdater<Head> {

    MultiUpdater(Head& head, Tail& ...args)
        : MultiUpdater<Tail...>{std::forward<Tail&>(args)...}
        , SingleUpdater<Head>{std::forward<Head&>(head)} {
    }

    void update(sf::Time const & elapsed) {
        SingleUpdater<Head>::update(elapsed);
        MultiUpdater<Tail...>::update(elapsed);
    }
};

template <>
struct MultiUpdater<> {
    MultiUpdater() {}

    void update(sf::Time const & elapsed) {}
};

template <typename... Args>
struct EntityUpdater
    : MultiUpdater<Args...> {

    EntityUpdater(Args& ...args)
        : MultiUpdater<Args...>{std::forward<Args&>(args)...} {
    }

    template <typename T>
    sf::Time& getTotal() {
        return SingleUpdater<T>::total;
    }
};

// ---------------------------------------------------------------------------

#include <iostream>
#include <thread>

struct SystemA {
    void update(sf::Time const & elapsed) {
        std::cout << "SystemA::update(" << elapsed.asMilliseconds() << "ms)\n";
        std::this_thread::sleep_for(std::chrono::duration<double, std::milli>(5));
    }
};

struct SystemB {
    void update(sf::Time const & elapsed) {
        std::cout << "SystemB::update(" << elapsed.asMilliseconds() << "ms)\n";
        std::this_thread::sleep_for(std::chrono::duration<double, std::milli>(15));
    }
};

struct SystemC {
    void update(sf::Time const & elapsed) {
        std::cout << "SystemC::update(" << elapsed.asMilliseconds() << "ms)\n";
        std::this_thread::sleep_for(std::chrono::duration<double, std::milli>(3));
    }
};

struct SystemD {
    void update(sf::Time const & elapsed) {
        std::cout << "SystemD::update(" << elapsed.asMilliseconds() << "ms)\n";
        std::this_thread::sleep_for(std::chrono::duration<double, std::milli>(8));
    }
};

int main() {
    SystemA a;
    SystemB b;
    SystemC c;
    SystemD d;

    EntityUpdater<SystemA, SystemD, SystemB, SystemC> updater{a, d, b, c};
    updater.update(sf::milliseconds(20));
    updater.update(sf::milliseconds(19));
    updater.update(sf::milliseconds(23));
    updater.update(sf::milliseconds(30));
    updater.update(sf::milliseconds(12));
    updater.update(sf::milliseconds(20));

    std::cout << "Total time for System A: " << updater.getTotal<SystemA>().asMilliseconds() << "ms\n";
    std::cout << "Total time for System B: " << updater.getTotal<SystemB>().asMilliseconds() << "ms\n";
    std::cout << "Total time for System C: " << updater.getTotal<SystemC>().asMilliseconds() << "ms\n";
    std::cout << "Total time for System D: " << updater.getTotal<SystemD>().asMilliseconds() << "ms\n";
}