al_SequenceServer.hpp

#ifndef INCLUDE_AL_SEQUENCESERVER
#define INCLUDE_AL_SEQUENCESERVER
 
#include <string>
 
#include "al/ui/al_ParameterServer.hpp"
#include "al/ui/al_PresetSequencer.hpp"
#include "al/ui/al_SequenceRecorder.hpp"
 
namespace al {
 
class SequenceServer : public osc::PacketHandler, public OSCNotifier {
 public:
  SequenceServer(std::string oscAddress = "127.0.0.1", int oscPort = 9012);
  SequenceServer(ParameterServer &paramServer);
  ~SequenceServer();
 
  virtual void onMessage(osc::Message &m);
 
  // Special cases of objects that are handled in specific ways
  SequenceServer &registerSequencer(PresetSequencer &sequencer);
  SequenceServer &registerRecorder(SequenceRecorder &recorder);
  SequenceServer &registerMessageConsumer(osc::MessageConsumer &consumer);
 
  void print();
 
  void stopServer();
 
  SequenceServer &operator<<(PresetSequencer &sequencer) {
    return registerSequencer(sequencer);
  }
  SequenceServer &operator<<(SequenceRecorder &recorder) {
    return registerRecorder(recorder);
  }
  SequenceServer &operator<<(osc::MessageConsumer &consumer) {
    return registerMessageConsumer(consumer);
  }
 
  void setAddress(std::string address);
  std::string getAddress();
 
 protected:
  //    void attachPacketHandler(osc::PacketHandler *handler);
  static void changeCallback(int value, void *sender, void *userData);
 
 private:
  osc::Recv *mServer;
  PresetSequencer *mSequencer;
  SequenceRecorder *mRecorder;
  // ParameterServer *mParamServer;
  std::vector<Composition *> mCompositions;
  //    std::mutex mServerLock;
  std::string mOSCpath;
  std::string mOSCQueryPath;
  //    std::mutex mHandlerLock;
  //    std::vector<osc::PacketHandler *> mHandlers;
  std::vector<osc::MessageConsumer *> mConsumers;
};
 
}  // namespace al
 
#endif  // INCLUDE_AL_SEQUENCESERVER