RealtimeEffectList.h

Go to the documentation of this file.

/**********************************************************************
 
 Audacity: A Digital Audio Editor
 
 RealtimeEffectList.h
 
 *********************************************************************/
 
#ifndef __AUDACITY_REALTIMEEFFECTLIST_H__
#define __AUDACITY_REALTIMEEFFECTLIST_H__
 
#include <atomic>
#include <optional>
#include <vector>
 
#include "PluginProvider.h" // for PluginID
#include "spinlock.h"
#include "UndoManager.h"
#include "XMLTagHandler.h"
#include "Observer.h"
 
class AudacityProject;
class ChannelGroup;
class RealtimeEffectState;
 
struct RealtimeEffectListMessage final
{
   enum class Type
   {
      Insert,
      WillReplace,
      DidReplace,
      Remove,
      Move 
   };
   Type type;
   size_t srcIndex;
   size_t dstIndex;
   std::shared_ptr<RealtimeEffectState> affectedState;
};
 
class REALTIME_EFFECTS_API RealtimeEffectList final
   // Inheritance from std::enable_shared_from_this must be public
   // but the per-group lists are managed by unique not shared pointers
   : public std::enable_shared_from_this<RealtimeEffectList>
   , public ClientData::Base
   , public ClientData::Cloneable<>
   , public UndoStateExtension
   , public XMLTagHandler
   , public Observer::Publisher<RealtimeEffectListMessage>
{
   RealtimeEffectList(const RealtimeEffectList &) = delete;
   RealtimeEffectList &operator=(const RealtimeEffectList &) = delete;
 
public:
   using Lock = spinlock;
   using States = std::vector<std::shared_ptr<RealtimeEffectState>>;
 
   RealtimeEffectList();
   virtual ~RealtimeEffectList();
 
   Lock &GetLock() const { return mLock; }
 
   std::unique_ptr<ClientData::Cloneable<>> Clone() const override;
 
   static RealtimeEffectList &Get(AudacityProject &project);
   static const RealtimeEffectList &Get(const AudacityProject &project);
   static RealtimeEffectList &Set(
      AudacityProject &project,
      const std::shared_ptr<RealtimeEffectList> &list);
 
   static RealtimeEffectList &Get(ChannelGroup &group);
   static const RealtimeEffectList &Get(const ChannelGroup &group);
 
   // Type that state visitor functions would have for out-of-line definition
   // of Visit
   // using StateVisitor =
      // std::function<void(RealtimeEffectState &state, bool listIsActive)> ;
 
   template<typename StateVisitor>
   void Visit(const StateVisitor &func)
   {
      for (auto &state : mStates)
         func(*state, IsActive());
   }
 
   template<typename StateVisitor>
   void Visit(const StateVisitor &func) const
   {
      for (const auto &state : mStates)
         func(*state, IsActive());
   }
 
 
   bool AddState(std::shared_ptr<RealtimeEffectState> pState);
 
 
   bool ReplaceState(size_t index, std::shared_ptr<RealtimeEffectState> pState);
 
   void RemoveState(std::shared_ptr<RealtimeEffectState> pState);
 
   void Clear();
 
   std::optional<size_t> FindState(
      const std::shared_ptr<RealtimeEffectState> &pState) const;
 
   size_t GetStatesCount() const noexcept;
   std::shared_ptr<RealtimeEffectState> GetStateAt(size_t index) noexcept;
   std::shared_ptr<const RealtimeEffectState> GetStateAt(size_t index) const
      noexcept;
 
   void MoveEffect(size_t fromIndex, size_t toIndex);
 
   static const std::string &XMLTag();
   bool HandleXMLTag(
      const std::string_view &tag, const AttributesList &attrs) override;
 
   XMLTagHandler *HandleXMLChild(const std::string_view &tag) override;
 
   void WriteXML(XMLWriter &xmlFile) const;
 
   void RestoreUndoRedoState(AudacityProject &project) noexcept override;
 
   bool IsActive() const;
 
   void SetActive(bool value);
 
private:
   States mStates;
 
   using LockGuard = std::lock_guard<Lock>;
   mutable Lock mLock;
 
   std::atomic<bool> mActive{ true };
};
 
#endif // __AUDACITY_REALTIMEEFFECTLIST_H__