Tickable.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <mutex>
#include <vector>
#include <stdint.h>
#include <stddef.h>
#ifdef COMPONENT_THREAD_SAFE
#include <atomic>
#endif
 
#include "ship/core/Action.h"
#include "ship/core/ActionList.h"
#include "ship/core/EventActionList.h"
#include "ship/events/EventTypes.h"
 
namespace Ship {
 
class Component;
 
class Tickable : public std::enable_shared_from_this<Tickable> {
  public:
    Tickable(const bool isTicking = true);
 
    Tickable(const bool isTicking, const std::vector<std::shared_ptr<Action>>& actions);
    virtual ~Tickable();
 
    bool IsTicking() const;
 
    bool Start(const bool force = false);
 
    bool Stop(const bool force = false);
 
    bool Tick(EventID eventId);
 
    bool Tick(const std::vector<EventID>& eventIds);
 
    template <typename T> bool Tick(const std::vector<EventID>& eventIds);
 
    template <typename T> bool Tick(EventID eventId);
 
    EventActionList& GetActionList();
 
    const EventActionList& GetActionList() const;
 
#ifdef INCLUDE_PROFILING
    double GetTime(const ClockType clockType) const;
#endif
 
  protected:
    virtual bool CanStart();
 
    virtual bool CanStop();
 
    virtual void Started(const bool forced);
 
    virtual void Stopped(const bool forced);
 
#ifdef COMPONENT_THREAD_SAFE
    std::mutex& GetMutex();
#endif
 
  private:
#ifdef INCLUDE_PROFILING
    Tickable& SetClock(const ClockType clockType, std::chrono::time_point<std::chrono::steady_clock> clockValue);
    std::chrono::time_point<std::chrono::steady_clock> GetClock(const ClockType clockType) const;
#endif
 
#ifdef COMPONENT_THREAD_SAFE
    std::atomic<bool> mIsTicking;
#else
    bool mIsTicking;
#endif
    EventActionList mActions;
#ifdef COMPONENT_THREAD_SAFE
    mutable std::mutex mMutex;
#endif
#ifdef INCLUDE_PROFILING
    std::chrono::time_point<std::chrono::steady_clock> mClocks[static_cast<size_t>(ClockType::ClockMax)];
#endif
};
 
// ---- Template method implementations ----
 
template <typename T> bool Tickable::Tick(const std::vector<EventID>& eventIds) {
#ifdef COMPONENT_THREAD_SAFE
    if (!mIsTicking.load(std::memory_order_acquire)) {
#else
    if (!mIsTicking) {
#endif
        return false;
    }
#ifdef INCLUDE_PROFILING
    const auto start = std::chrono::steady_clock::now();
#endif
    bool ran = false;
    auto allActions = mActions.Get(eventIds);
    for (const auto& action : *allActions) {
        if (std::dynamic_pointer_cast<T>(action)) {
            ran = action->Run() || ran;
        }
    }
#ifdef INCLUDE_PROFILING
    const auto end = std::chrono::steady_clock::now();
    (void)end;
    (void)start;
#endif
    return ran;
}
 
template <typename T> bool Tickable::Tick(EventID eventId) {
#ifdef COMPONENT_THREAD_SAFE
    if (!mIsTicking.load(std::memory_order_acquire)) {
#else
    if (!mIsTicking) {
#endif
        return false;
    }
#ifdef INCLUDE_PROFILING
    const auto start = std::chrono::steady_clock::now();
#endif
    bool ran = false;
    auto allActions = mActions.Get(eventId);
    for (const auto& action : *allActions) {
        if (std::dynamic_pointer_cast<T>(action)) {
            ran = action->Run() || ran;
        }
    }
#ifdef INCLUDE_PROFILING
    const auto end = std::chrono::steady_clock::now();
    (void)end;
    (void)start;
#endif
    return ran;
}
 
} // namespace Ship