ChannelAttachments.h

Go to the documentation of this file.

/*!********************************************************************
 
  Audacity: A Digital Audio Editor
 
  @file ChannelAttachments.h
  @brief Adapts TrackAttachment interface with extra channel index argument
 
  Dominic Mazzoni
 
  Paul Licameli split from Track.h
 
**********************************************************************/
#ifndef __AUDACITY_CHANNEL_ATTACHMENTS__
#define __AUDACITY_CHANNEL_ATTACHMENTS__
 
#include "Track.h"
 
class TRACK_API ChannelAttachment
{
public:
   virtual ~ChannelAttachment();
 
 
   virtual void CopyTo(Track &track, size_t iChannel) const;
 
 
   virtual void Reparent(const std::shared_ptr<Track> &parent, size_t iChannel);
 
 
   virtual void WriteXMLAttributes(XMLWriter &writer, size_t iChannel) const;
 
 
   virtual bool HandleXMLAttribute(
      const std::string_view& attr, const XMLAttributeValueView& valueView,
      size_t iChannel);
};
 
class TRACK_API ChannelAttachmentsBase : public TrackAttachment
{
public:
   using Factory =
      std::function<std::shared_ptr<ChannelAttachment>(Track &, size_t)>;
 
   ChannelAttachmentsBase(Track &track, Factory factory);
   ~ChannelAttachmentsBase() override;
 
   // No copying
   ChannelAttachmentsBase(const ChannelAttachmentsBase &) = delete;
   ChannelAttachmentsBase &operator=(const ChannelAttachmentsBase &) = delete;
 
   // No move construction
   ChannelAttachmentsBase(ChannelAttachmentsBase &) = delete;
 
   // Move assignment is allowed
   ChannelAttachmentsBase &operator=(ChannelAttachmentsBase &&other);
 
   size_t Size() const { return mAttachments.size(); }
 
   // Override all the TrackAttachment virtuals and pass through to each
   void CopyTo(Track &track) const override;
   void Reparent(const std::shared_ptr<Track> &parent) override;
   void WriteXMLAttributes(XMLWriter &writer) const override;
   bool HandleXMLAttribute(
      const std::string_view& attr, const XMLAttributeValueView& valueView)
   override;
 
 
   void MakeStereo(const std::shared_ptr<Track> &parent,
      ChannelAttachmentsBase &&other);
 
   void SwapChannels(const std::shared_ptr<Track> &parent);
 
 
   void Erase(const std::shared_ptr<Track> &parent, size_t index);
 
protected:
   static ChannelAttachment &Get(
      const AttachedTrackObjects::RegisteredFactory &key,
      Track &track, size_t iChannel);
   static ChannelAttachment *Find(
      const AttachedTrackObjects::RegisteredFactory &key,
      Track *pTrack, size_t iChannel);
 
private:
   const Factory mFactory;
   std::vector<std::shared_ptr<ChannelAttachment>> mAttachments;
};
 
template<typename Attachment>
class ChannelAttachments : public ChannelAttachmentsBase
{
   static_assert(std::is_base_of_v<ChannelAttachment, Attachment>);
public:
   ~ChannelAttachments() override = default;
 
   static Attachment &Get(
      const AttachedTrackObjects::RegisteredFactory &key,
      Track &track, size_t iChannel)
   {
      return static_cast<Attachment&>(
         ChannelAttachmentsBase::Get(key, track, iChannel));
   }
   static Attachment *Find(
      const AttachedTrackObjects::RegisteredFactory &key,
      Track *pTrack, size_t iChannel)
   {
      return static_cast<Attachment*>(
         ChannelAttachmentsBase::Find(key, pTrack, iChannel));
   }
 
 
   template<typename F,
      typename sfinae = std::enable_if_t<std::is_convertible_v<
         std::invoke_result_t<F, Track&, size_t>, std::shared_ptr<Attachment>
      >>
   >
   explicit ChannelAttachments(Track &track, F &&f)
      : ChannelAttachmentsBase{ track, std::forward<F>(f) }
   {}
};
 
#endif