Add a listener holder helper class.

Author: Mysticial

Common/Cpp/ListenerSet.h

@@ -0,0 +1,87 @@
+/*  Listener Set
+ *
+ *  From: https://github.com/PokemonAutomation/Arduino-Source
+ *
+ */
+
+#ifndef PokemonAutomation_ListenerSet_H
+#define PokemonAutomation_ListenerSet_H
+
+#include <map>
+#include <mutex>
+
+namespace PokemonAutomation{
+
+
+
+template <typename ListenerType>
+class ListenerSet{
+public:
+    size_t count_unique() const{
+        std::lock_guard<std::mutex> lg(m_lock);
+        return m_listeners.size();
+    }
+
+    void add(ListenerType& listener){
+        std::lock_guard<std::mutex> lg(m_lock);
+        m_listeners[&listener]++;
+    }
+    void remove(ListenerType& listener){
+        std::lock_guard<std::mutex> lg(m_lock);
+        auto iter = m_listeners.find(&listener);
+        if (iter == m_listeners.end()){
+            return;
+        }
+        if (--iter->second == 0){
+            m_listeners.erase(iter);
+        }
+    }
+
+    template <typename Lambda>
+    void run_lambda_unique(Lambda&& lambda){
+        std::lock_guard<std::mutex> lg(m_lock);
+        for (auto& item : m_listeners){
+            lambda(*item.first);
+        }
+    }
+    template <typename Lambda>
+    void run_lambda_with_duplicates(Lambda&& lambda){
+        std::lock_guard<std::mutex> lg(m_lock);
+        for (auto& item : m_listeners){
+            ListenerType& listener = *item.first;
+            size_t count = item.second;
+            do{
+                lambda(listener);
+            }while (--count);
+        }
+    }
+
+    template <typename Function, class... Args>
+    void run_method_unique(Function function, Args&&... args){
+        std::lock_guard<std::mutex> lg(m_lock);
+        for (auto& item : m_listeners){
+            (item.first->*function)(std::forward<Args>(args)...);
+        }
+    }
+    template <typename Function, class... Args>
+    void run_method_with_duplicates(Function function, Args&&... args){
+        std::lock_guard<std::mutex> lg(m_lock);
+        for (auto& item : m_listeners){
+            ListenerType& listener = *item.first;
+            size_t count = item.second;
+            do{
+                (listener->*function)(std::forward<Args>(args)...);
+            }while (--count);
+        }
+    }
+
+private:
+    mutable std::mutex m_lock;
+    std::map<ListenerType*, size_t> m_listeners;
+};
+
+
+
+
+}
+#endif

SerialPrograms/Source/CommonFramework/AudioPipeline/AudioSession.cpp

@@ -23,12 +23,10 @@ namespace PokemonAutomation{
 
 
 void AudioSession::add_state_listener(StateListener& listener){
-    std::lock_guard<std::mutex> lg(m_lock);
-    m_listeners.insert(&listener);
+    m_listeners.add(listener);
 }
 void AudioSession::remove_state_listener(StateListener& listener){
-    std::lock_guard<std::mutex> lg(m_lock);
-    m_listeners.erase(&listener);
+    m_listeners.remove(listener);
 }
 void AudioSession::add_stream_listener(AudioFloatStreamListener& listener){
     m_devices->add_listener(listener);
@@ -74,33 +72,33 @@ void AudioSession::get(AudioOption& option){
     option.m_display_type   = m_option.m_display_type;
 }
 void AudioSession::set(const AudioOption& option){
-    std::lock_guard<std::mutex> lg(m_lock);
-    signal_pre_input_change();
+    {
+        std::lock_guard<std::mutex> lg(m_lock);
+        signal_pre_input_change();
 
-    m_option.m_input_file       = option.m_input_file;
-    m_option.m_input_device     = option.m_input_device;
-    m_option.m_input_format     = option.m_input_format;
-    m_option.m_output_device    = option.m_output_device;
-    m_option.m_volume           = option.m_volume;
-    m_option.m_display_type     = option.m_display_type;
+        m_option.m_input_file       = option.m_input_file;
+        m_option.m_input_device     = option.m_input_device;
+        m_option.m_input_format     = option.m_input_format;
+        m_option.m_output_device    = option.m_output_device;
+        m_option.m_volume           = option.m_volume;
+        m_option.m_display_type     = option.m_display_type;
 
-    if (!m_option.m_input_file.empty()){
-        sanitize_format();
-        m_devices->set_audio_source(m_option.m_input_file);
-    }else if (sanitize_format()){
-        m_devices->set_audio_source(m_option.m_input_device, m_option.m_input_format);
-    }else{
-        m_devices->clear_audio_source();
-    }
+        if (!m_option.m_input_file.empty()){
+            sanitize_format();
+            m_devices->set_audio_source(m_option.m_input_file);
+        }else if (sanitize_format()){
+            m_devices->set_audio_source(m_option.m_input_device, m_option.m_input_format);
+        }else{
+            m_devices->clear_audio_source();
+        }
 
-    m_devices->set_audio_sink(m_option.m_output_device, m_option.m_volume);
+        m_devices->set_audio_sink(m_option.m_output_device, m_option.m_volume);
+    }
 
     signal_post_input_change();
     signal_post_output_change();
-    for (StateListener* listener : m_listeners){
-        listener->post_volume_change(m_option.volume());
-        listener->post_display_change(m_option.m_display_type);
-    }
+    m_listeners.run_method_unique(&StateListener::post_volume_change, m_option.volume());
+    m_listeners.run_method_unique(&StateListener::post_display_change, m_option.m_display_type);
 }
 std::pair<std::string, AudioDeviceInfo> AudioSession::input_device() const{
     std::lock_guard<std::mutex> lg(m_lock);
@@ -193,25 +191,25 @@ void AudioSession::set_audio_output(AudioDeviceInfo info){
     signal_post_output_change();
 }
 void AudioSession::set_volume(double volume){
-    std::lock_guard<std::mutex> lg(m_lock);
-    if (m_option.m_volume == volume){
-        return;
-    }
-    m_devices->set_sink_volume(volume);
-    m_option.m_volume = volume;
-    for (StateListener* listener : m_listeners){
-        listener->post_volume_change(m_option.volume());
+    {
+        std::lock_guard<std::mutex> lg(m_lock);
+        if (m_option.m_volume == volume){
+            return;
+        }
+        m_devices->set_sink_volume(volume);
+        m_option.m_volume = volume;
     }
+    m_listeners.run_method_unique(&StateListener::post_volume_change, m_option.volume());
 }
 void AudioSession::set_display(AudioOption::AudioDisplayType display){
-    std::lock_guard<std::mutex> lg(m_lock);
-    if (m_option.m_display_type == display){
-        return;
-    }
-    m_option.m_display_type = display;
-    for (StateListener* listener : m_listeners){
-        listener->post_display_change(m_option.m_display_type);
+    {
+        std::lock_guard<std::mutex> lg(m_lock);
+        if (m_option.m_display_type == display){
+            return;
+        }
+        m_option.m_display_type = display;
     }
+    m_listeners.run_method_unique(&StateListener::post_display_change, m_option.m_display_type);
 }
 
 bool AudioSession::sanitize_format(){
@@ -243,19 +241,18 @@ bool AudioSession::sanitize_format(){
     return true;
 }
 void AudioSession::signal_pre_input_change(){
-    for (StateListener* listener : m_listeners){
-        listener->pre_input_change();
-    }
+    m_listeners.run_method_unique(&StateListener::pre_input_change);
 }
 void AudioSession::signal_post_input_change(){
-    for (StateListener* listener : m_listeners){
-        listener->post_input_change(m_option.input_file(), m_option.input_device(), m_option.input_format());
-    }
+    m_listeners.run_method_unique(
+        &StateListener::post_input_change,
+        m_option.input_file(),
+        m_option.input_device(),
+        m_option.input_format()
+    );
 }
 void AudioSession::signal_post_output_change(){
-    for (StateListener* listener : m_listeners){
-        listener->post_output_change(m_option.output_device());
-    }
+    m_listeners.run_method_unique(&StateListener::post_output_change, m_option.output_device());
 }
 
 
@@ -290,7 +287,7 @@ void AudioSession::add_overlay(uint64_t starting_seqnum, size_t end_seqnum, Colo
 }
 
 
-void AudioSession::on_fft(size_t sample_rate, std::shared_ptr<AlignedVector<float>> fft_output){
+void AudioSession::on_fft(size_t sample_rate, std::shared_ptr<const AlignedVector<float>> fft_output){
     m_spectrum_holder.push_spectrum(sample_rate, std::move(fft_output));
     global_watchdog().delay(*this);
 }

SerialPrograms/Source/CommonFramework/AudioPipeline/AudioSession.h

@@ -16,6 +16,7 @@
 #ifndef PokemonAutomation_AudioPipeline_AudioSession_H
 #define PokemonAutomation_AudioPipeline_AudioSession_H
 
+#include "Common/Cpp/ListenerSet.h"
 #include "Common/Cpp/Concurrency/Watchdog.h"
 #include "AudioFeed.h"
 #include "AudioPassthroughPair.h"
@@ -82,7 +83,7 @@ class AudioSession final : public AudioFeed, private FFTListener, private Watchd
 
 
 private:
-    virtual void on_fft(size_t sample_rate, std::shared_ptr<AlignedVector<float>> fft_output) override;
+    virtual void on_fft(size_t sample_rate, std::shared_ptr<const AlignedVector<float>> fft_output) override;
     virtual void on_watchdog_timeout() override;
 
     bool sanitize_format();
@@ -99,7 +100,9 @@ class AudioSession final : public AudioFeed, private FFTListener, private Watchd
     std::unique_ptr<AudioPassthroughPair> m_devices;
 
     mutable std::mutex m_lock;
-    std::set<StateListener*> m_listeners;
+
+    ListenerSet<StateListener> m_listeners;
+
 };
 
 

SerialPrograms/Source/CommonFramework/AudioPipeline/AudioStream.cpp

@@ -141,11 +141,11 @@ void AudioFloatToStream::add_listener(StreamListener& listener){
     if (listener.object_size != m_frame_size){
         throw InternalProgramError(nullptr, PA_CURRENT_FUNCTION, "Mismatching frame size.");
     }
-    m_listeners.insert(&listener);
+    m_listeners.add(listener);
 }
 void AudioFloatToStream::remove_listener(StreamListener& listener){
     auto scope_check = m_sanitizer.check_scope();
-    m_listeners.erase(&listener);
+    m_listeners.remove(listener);
 }
 
 AudioFloatToStream::AudioFloatToStream(AudioSampleFormat output_format, size_t samples_per_frame)
@@ -171,9 +171,10 @@ void AudioFloatToStream::on_samples(const float* data, size_t frames){
         return;
     }
     if (m_format == AudioSampleFormat::FLOAT32){
-        for (StreamListener* listener : m_listeners){
-            listener->on_objects(data, frames);
-        }
+        m_listeners.run_method_unique(
+            &StreamListener::on_objects,
+            data, frames
+        );
         return;
     }
 
@@ -195,9 +196,10 @@ void AudioFloatToStream::on_samples(const float* data, size_t frames){
         default:
             return;
         }
-        for (StreamListener* listener : m_listeners){
-            listener->on_objects(m_buffer.data(), block);
-        }
+        m_listeners.run_method_unique(
+            &StreamListener::on_objects,
+            m_buffer.data(), block
+        );
         data = (const float*)((const char*)data + block * m_frame_size);
         frames -= block;
     }

SerialPrograms/Source/CommonFramework/AudioPipeline/AudioStream.h

@@ -7,8 +7,8 @@
 #ifndef PokemonAutomation_AudioPipeline_AudioSourceReader_H
 #define PokemonAutomation_AudioPipeline_AudioSourceReader_H
 
+#include "Common/Cpp/ListenerSet.h"
 #include "Common/Cpp/LifetimeSanitizer.h"
-#include "Common/Cpp/Time.h"
 #include "Common/Cpp/StreamConverters.h"
 #include "Common/Cpp/Containers/AlignedVector.h"
 #include "AudioInfo.h"
@@ -81,7 +81,7 @@ class AudioFloatToStream : public AudioFloatStreamListener{
     size_t m_frame_size;
     size_t m_buffer_size;
     AlignedVector<char> m_buffer;
-    std::set<StreamListener*> m_listeners;
+    ListenerSet<StreamListener> m_listeners;
 
     LifetimeSanitizer m_sanitizer;
 };