al_ComputationDomain.hpp

#ifndef COMPUTATIONDOMAIN_H
#define COMPUTATIONDOMAIN_H
 
#include <cassert>
#include <functional>
#include <iostream>
#include <memory>
#include <mutex>
#include <stack>
#include <vector>
 
#include "al/ui/al_Parameter.hpp"
 
namespace al {
class SynchronousDomain;
 
class ComputationDomain {
public:
  virtual ~ComputationDomain() {}
  virtual bool init(ComputationDomain *parent = nullptr);
 
  virtual bool cleanup(ComputationDomain *parent = nullptr);
 
  template <class DomainType>
  std::shared_ptr<DomainType> newSubDomain(bool prepend = false);
 
  void removeSubDomain(std::shared_ptr<SynchronousDomain> subDomain);
 
  double timeDelta() { return mTimeDrift; }
 
  void setTimeDelta(double delta) { mTimeDrift = delta; }
 
  void
  registerInitializeCallback(std::function<void(ComputationDomain *)> callback);
 
  void
  registerCleanupCallback(std::function<void(ComputationDomain *)> callback);
 
  std::vector<ParameterMeta *> parameters() { return mParameters; }
 
protected:
  bool initializeSubdomains(bool pre = false);
 
  bool tickSubdomains(bool pre = false);
 
  bool cleanupSubdomains(bool pre = false);
 
  void callInitializeCallbacks();
 
  void callCleanupCallbacks();
 
  std::mutex mSubdomainLock; // It is the domain's responsibility to lock and
                             // unlock while processing.
  double mTimeDrift{0.0};
  std::vector<std::pair<std::shared_ptr<SynchronousDomain>, bool>>
      mSubDomainList;
 
  // Add parameters for domain control here
  std::vector<ParameterMeta *> mParameters;
 
private:
  std::vector<std::function<void(ComputationDomain *)>> mInitializeCallbacks;
  std::vector<std::function<void(ComputationDomain *)>> mCleanupCallbacks;
};
 
class SynchronousDomain : public ComputationDomain {
  friend class ComputationDomain;
 
public:
  virtual bool tick();
};
 
class AsynchronousDomain : public ComputationDomain {
public:
  virtual bool start() = 0;
 
  virtual bool stop() = 0;
 
protected:
  void callStartCallbacks();
 
  void callStopCallbacks() {
    for (auto callback : mStopCallbacks) {
      callback(this);
    }
  }
 
private:
  std::vector<std::function<void(ComputationDomain *)>> mStartCallbacks;
  std::vector<std::function<void(ComputationDomain *)>> mStopCallbacks;
};
 
template <class DomainType>
std::shared_ptr<DomainType> ComputationDomain::newSubDomain(bool prepend) {
  //  std::lock_guard<std::mutex> lk(mSubdomainLock);
  // Only Synchronous domains are allowed as subdomains
  auto newDomain = std::make_shared<DomainType>();
  assert(dynamic_cast<SynchronousDomain *>(newDomain.get()));
  if (newDomain) {
    mSubDomainList.push_back({newDomain, prepend});
    //    if (newDomain->init(this)) {
    //    } else {
    //      newDomain = nullptr;
    //    }
  }
  return newDomain;
}
 
} // namespace al
 
#endif // COMPUTATIONDOMAIN_H