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