Sustain.h

Go to the documentation of this file.

#pragma once
#include <limits>
#include <misc/gen/IntervalTimer.h>
#include <misc/gen/TVector.h>
#include <misc/gen/target.h>
#include <misc/global.h>
 
namespace sf
{
 
class _MISC_CLASS SustainBase
{
  public:
    typedef TVector<SustainBase*> PtrVector;
 
    enum ESustainPriority : int
    {
      spDefault = 100,
      spTimer = std::numeric_limits<int>::max()
    };
 
    SustainBase(const SustainBase&) = delete;
 
    SustainBase& operator=(const SustainBase&) = delete;
 
  protected:
    SustainBase(PtrVector* vector, int priority);
 
    ~SustainBase();
 
  public:
    [[nodiscard]] int getPriority() const;
 
    void setInterval(const timespec& interval);
 
    [[nodiscard]] const timespec& getInterval() const;
 
    void enable();
 
    void disable();
 
    [[nodiscard]] bool isEnabled() const;
 
    virtual inline bool call(const timespec& time);
 
    static void flushVector(PtrVector* vector);
 
    static void callSustain(PtrVector* vector = nullptr);
 
  protected:
    static PtrVector* _defaultVector;
    int _priority;
    PtrVector* _list;
    IntervalTimer _timer;
};
 
inline void SustainBase::setInterval(const timespec& interval)
{
  _timer.set(interval);
}
 
inline const timespec& SustainBase::getInterval() const
{
  return _timer.getInterval();
}
 
inline void SustainBase::enable()
{
  _timer.enable();
}
 
inline void SustainBase::disable()
{
  _timer.disable();
}
 
inline bool SustainBase::isEnabled() const
{
  return _timer.isEnabled();
}
 
inline bool SustainBase::call(const timespec& time)
{
  return false;
}
 
template<typename T>
class TSustain : public SustainBase
{
  public:
    typedef bool (T::*Pmf)(const timespec& t);
 
    virtual ~TSustain() = default;
 
    TSustain(T* self, Pmf pmf, int priority = spDefault, PtrVector* vector = nullptr);
 
    TSustain(const TSustain&) = delete;
 
    TSustain& operator=(const TSustain&) = delete;
 
  private:
    Pmf _pmf;
    T* _self;
 
    inline bool call(const timespec& tm) override
    {
      return (_self->*_pmf)(tm);
    }
};
 
template<typename T>
TSustain<T>::TSustain(T* self, Pmf pmf, int priority, PtrVector* vector)
  : SustainBase(vector, priority)
  , _self(self)
  , _pmf(pmf)
{}
 
class _MISC_CLASS StaticSustain : public SustainBase
{
  public:
    typedef bool (*Pf)(const timespec&);
 
    explicit StaticSustain(Pf pf, int priority = spDefault, PtrVector* vector = _defaultVector)
      : SustainBase(vector, priority)
      , _pf(pf)
    {}
 
    StaticSustain(const StaticSustain&) = delete;
 
    StaticSustain& operator=(const StaticSustain&) = delete;
 
  private:
    Pf _pf{};
 
    bool call(const timespec& time) override;
};
 
inline int SustainBase::getPriority() const
{
  return _priority;
}
 
inline bool StaticSustain::call(const timespec& time)
{
  return _pf(time);
}
 
_MISC_FUNC bool setSustainTimer(int msec);
 
_MISC_FUNC int getSustainTimer();
 
}// namespace sf