TimerScheduler.h

 
#ifndef MFRAME_3B90E2BA_6408_488A_8ECE_2AEE76F41A39
#define MFRAME_3B90E2BA_6408_488A_8ECE_2AEE76F41A39
 
/* ***************************************************************************************
 * Include
 */
 
//----------------------------------------------------------------------------------------
#include "./../lang/Memory.h"
#include "./../lang/NonCopyable.h"
#include "./../lang/Object.h"
#include "./../lang/Updatable.h"
#include "./../util/Container.h"
//----------------------------------------------------------------------------------------
 
/* ***************************************************************************************
 * Namespace
 */
namespace ufm::util {
  class TimerScheduler;
}  // namespace ufm::util
 
/* ***************************************************************************************
 * Class/Interface/Struct/Enum
 */
 
class ufm::util::TimerScheduler : public ufm::lang::Object,
                                  public ufm::lang::Updatable,
                                  public ufm::util::Container,
                                  public ufm::lang::NonCopyable {
  /* *************************************************************************************
   * Class/Interface/Struct/Enum
   */
 public:
  struct Task;
  struct Block;
 
  /* *************************************************************************************
   * Variable
   */
 private:
  ufm::lang::Memory vMemory;
  int               vSize;
 
  /* *************************************************************************************
   * Abstract Method
   */
 
  /* *************************************************************************************
   * Construct Method
   */
 public:
  TimerScheduler(const ufm::lang::Memory& memory);
 
  template <size_t N>
  TimerScheduler(uint32 (&buffer)[N])
      : TimerScheduler(ufm::lang::Memory(buffer, sizeof(buffer))) {
    return;
  }
 
  virtual ~TimerScheduler(void) override;
 
  /* *************************************************************************************
   * Operator Method
   */
 
  /* *************************************************************************************
   * Override - ufm::util::Container
   */
 public:
  virtual void clear(void) override;
 
  virtual bool isEmpty(void) const override;
 
  virtual int size(void) const override;
 
  /* *************************************************************************************
   * Override - ufm::lang::Updatable
   */
 public:
  virtual void update(void) override;
 
  /* *************************************************************************************
   * Public Method
   */
 public:
  bool schedule(Task& task, uint64 delayMicroseconds);
 
  inline bool scheduleAtMilliseconds(Task& task, uint64 delayMilliseconds) {
    return this->schedule(task, delayMilliseconds * 1000);
  }
 
  inline bool scheduleAtSeconds(Task& task, uint64 delaySeconds) {
    return this->schedule(task, delaySeconds * 1000000);
  }
 
  /* *************************************************************************************
   * Protected Method
   */
 
  /* *************************************************************************************
   * Private Method
   */
 
  /* *************************************************************************************
   * Static Variable
   */
 
  /* *************************************************************************************
   * Static Method
   */
};
 
struct ufm::util::TimerScheduler::Task {
  /* *************************************************************************************
   * Method
   */
 
  virtual void timerTask(ufm::util::TimerScheduler& scheduler) abstract;
};
 
struct ufm::util::TimerScheduler::Block {
  TimerScheduler::Task* task;  
  uint64                time;  
};
 
/* ***************************************************************************************
 * End of file
 */
 
#endif /* MFRAME_3B90E2BA_6408_488A_8ECE_2AEE76F41A39 */