Channel.h

Go to the documentation of this file.

/*!********************************************************************
 
  Audacity: A Digital Audio Editor
 
  @file Channel.h
  @brief Abstract class ChannelGroup with two discrete iterable dimensions,
  channels and intervals; subclasses associate information with those and
  their intersections
 
  Dominic Mazzoni
 
  Paul Licameli split from Track.h
 
**********************************************************************/
#ifndef __AUDACITY_CHANNEL__
#define __AUDACITY_CHANNEL__
 
#include <cassert>
#include <optional>
#include <vector>
 
#include "ClientData.h"
#include "MemoryX.h"
 
 
class CHANNEL_API ChannelGroupInterval {
public:
   ChannelGroupInterval(double start, double end)
      : mStart{ start }, mEnd{ end }
   {
      assert(start <= end);
   }
 
   virtual ~ChannelGroupInterval();
 
   double Start() const { return mStart; }
   double End() const { return mEnd; }
 
private:
   const double mStart, mEnd;
};
 
class CHANNEL_API ChannelInterval {
public:
   virtual ~ChannelInterval();
};
 
class ChannelGroup;
 
 
class CHANNEL_API WideChannelGroupInterval : public ChannelGroupInterval {
public:
 
   WideChannelGroupInterval(
      const ChannelGroup &group, double start, double end);
   ~WideChannelGroupInterval() override;
 
 
   size_t NChannels() const { return mNChannels; }
 
 
   template<typename IntervalType = ChannelInterval>
   std::shared_ptr<IntervalType> GetChannel(size_t iChannel)
   {
      return
         std::dynamic_pointer_cast<IntervalType>(DoGetChannel(iChannel));
   }
 
   template<typename IntervalType = const ChannelInterval>
   auto GetChannel(size_t iChannel) const
      -> std::enable_if_t<std::is_const_v<IntervalType>,
         std::shared_ptr<IntervalType>>
   {
      return std::dynamic_pointer_cast<IntervalType>(
         const_cast<WideChannelGroupInterval*>(this)->DoGetChannel(iChannel));
   }
 
   template<typename IntervalType>
   class ChannelIterator
      : public ValueIterator<
         std::shared_ptr<IntervalType>, std::bidirectional_iterator_tag
      >
   {
      using GroupType = std::conditional_t<std::is_const_v<IntervalType>,
         const WideChannelGroupInterval, WideChannelGroupInterval>;
   public:
      ChannelIterator() = default;
      ChannelIterator(GroupType *pGroup, size_t index)
         : mpGroup{ pGroup }, mIndex{ index }
      {}
 
      std::shared_ptr<IntervalType> operator *() const
      {
         if (!mpGroup || mIndex >= mpGroup->NChannels())
            return {};
         return mpGroup->template GetChannel<IntervalType>(mIndex);
      }
 
      ChannelIterator &operator ++() { ++mIndex; return *this; }
      ChannelIterator operator ++(int)
         { auto copy{ *this }; operator ++(); return copy; }
 
      ChannelIterator &operator --() { --mIndex; return *this; }
      ChannelIterator operator --(int)
         { auto copy{ *this }; operator --(); return copy; }
 
      friend inline bool operator ==(ChannelIterator a, ChannelIterator b)
         { return a.mpGroup == b.mpGroup && a.mIndex == b.mIndex; }
      friend inline bool operator !=(ChannelIterator a, ChannelIterator b)
         { return !(a == b); }
 
   private:
      GroupType *mpGroup{};
      size_t mIndex{};
   };
 
   template<typename IntervalType = ChannelInterval>
   IteratorRange<ChannelIterator<IntervalType>> Channels()
   {
      return { { this, 0 }, { this, NChannels() } };
   }
 
   template<typename IntervalType = const ChannelInterval>
   auto Channels() const
      -> std::enable_if_t<std::is_const_v<IntervalType>,
         IteratorRange<ChannelIterator<IntervalType>>
      >
   {
      return { { this, 0 }, { this, NChannels() } };
   }
 
protected:
 
   virtual std::shared_ptr<ChannelInterval> DoGetChannel(size_t iChannel) = 0;
 
private:
   const size_t mNChannels;
};
 
class CHANNEL_API Channel
{
public:
   virtual ~Channel();
 
   ChannelGroup &GetChannelGroup();
   const ChannelGroup &GetChannelGroup() const;
 
   size_t GetChannelIndex() const;
 
   size_t ReallyGetChannelIndex() const;
 
   using Interval = ChannelInterval;
 
   size_t NIntervals() const;
 
 
   template<typename IntervalType = Interval>
   std::shared_ptr<IntervalType> GetInterval(size_t iInterval);
 
   template<typename IntervalType = const Interval>
   auto GetInterval(size_t iInterval) const
      -> std::enable_if_t<std::is_const_v<IntervalType>,
         std::shared_ptr<IntervalType>>;
 
 
   template<typename IntervalType>
   class IntervalIterator
      : public ValueIterator<
         std::shared_ptr<IntervalType>, std::bidirectional_iterator_tag
      >
   {
      using ChannelType = std::conditional_t<std::is_const_v<IntervalType>,
         const Channel, Channel>;
   public:
      IntervalIterator() = default;
      IntervalIterator(ChannelType *pChannel, size_t index)
         : mpChannel{ pChannel }, mIndex{ index }
      {}
 
      std::shared_ptr<IntervalType> operator *() const
      {
         if (!mpChannel || mIndex >= mpChannel->NIntervals())
            return {};
         return mpChannel->template GetInterval<IntervalType>(mIndex);
      }
 
      IntervalIterator &operator ++() { ++mIndex; return *this; }
      IntervalIterator operator ++(int)
         { auto copy{ *this }; operator ++(); return copy; }
 
      IntervalIterator &operator --() { --mIndex; return *this; }
      IntervalIterator operator --(int)
         { auto copy{ *this }; operator --(); return copy; }
 
      friend inline bool operator ==(IntervalIterator a, IntervalIterator b)
         { return a.mpChannel == b.mpChannel && a.mIndex == b.mIndex; }
      friend inline bool operator !=(IntervalIterator a, IntervalIterator b)
         { return !(a == b); }
 
   private:
      ChannelType *mpChannel{};
      size_t mIndex{};
   };
 
   template<typename IntervalType = Interval>
   IteratorRange<IntervalIterator<IntervalType>> Intervals()
   {
      return { { this, 0 }, { this, NIntervals() } };
   }
 
   template<typename IntervalType = const Interval>
   auto Intervals() const
      -> std::enable_if_t<std::is_const_v<IntervalType>,
         IteratorRange<IntervalIterator<IntervalType>>
      >
   {
      return { { this, 0 }, { this, NIntervals() } };
   }
 
protected:
 
   virtual ChannelGroup &DoGetChannelGroup() const = 0;
 
   virtual ChannelGroup &ReallyDoGetChannelGroup() const;
 
private:
   int FindChannelIndex() const;
};
 
class CHANNEL_API ChannelGroup
{
public:
   virtual ~ChannelGroup();
 
   double GetStartTime() const;
   double GetEndTime() const;
 
   /*
    @pre `IsLeader()`
    */
   void ShiftBy(double t) { MoveTo(GetStartTime() + t); }
 
   /*
    @pre `IsLeader()`
    */
   virtual void MoveTo(double o) = 0;
 
 
   virtual size_t NChannels() const = 0;
 
 
   template<typename ChannelType = Channel>
   std::shared_ptr<ChannelType> GetChannel(size_t iChannel)
   {
      return
         std::dynamic_pointer_cast<ChannelType>(DoGetChannel(iChannel));
   }
 
   template<typename ChannelType = const Channel>
   auto GetChannel(size_t iChannel) const
      -> std::enable_if_t<std::is_const_v<ChannelType>,
         std::shared_ptr<ChannelType>>
   {
      return std::dynamic_pointer_cast<ChannelType>(
         const_cast<ChannelGroup*>(this)->DoGetChannel(iChannel));
   }
 
   template<typename ChannelType>
   class ChannelIterator
      : public ValueIterator<
         std::shared_ptr<ChannelType>, std::bidirectional_iterator_tag
      >
   {
      using GroupType = std::conditional_t<std::is_const_v<ChannelType>,
         const ChannelGroup, ChannelGroup>;
   public:
      ChannelIterator() = default;
      ChannelIterator(GroupType *pGroup, size_t index)
         : mpGroup{ pGroup }, mIndex{ index }
      {}
 
      std::shared_ptr<ChannelType> operator *() const
      {
         if (!mpGroup || mIndex >= mpGroup->NChannels())
            return {};
         return mpGroup->template GetChannel<ChannelType>(mIndex);
      }
 
      ChannelIterator &operator ++() { ++mIndex; return *this; }
      ChannelIterator operator ++(int)
         { auto copy{ *this }; operator ++(); return copy; }
 
      ChannelIterator &operator --() { --mIndex; return *this; }
      ChannelIterator operator --(int)
         { auto copy{ *this }; operator --(); return copy; }
 
      friend inline bool operator ==(ChannelIterator a, ChannelIterator b)
         { return a.mpGroup == b.mpGroup && a.mIndex == b.mIndex; }
      friend inline bool operator !=(ChannelIterator a, ChannelIterator b)
         { return !(a == b); }
 
   private:
      GroupType *mpGroup{};
      size_t mIndex{};
   };
 
 
   template<typename ChannelType = Channel>
   IteratorRange<ChannelIterator<ChannelType>> Channels()
   {
      assert(IsLeader());
      return { { this, 0 }, { this, NChannels() } };
   }
 
 
   template<typename ChannelType = const Channel>
   auto Channels() const
      -> std::enable_if_t<std::is_const_v<ChannelType>,
         IteratorRange<ChannelIterator<ChannelType>>
      >
   {
      assert(IsLeader());
      return { { this, 0 }, { this, NChannels() } };
   }
 
   using Interval = WideChannelGroupInterval;
 
   virtual size_t NIntervals() const = 0;
 
 
   template<typename IntervalType = Interval>
   std::shared_ptr<IntervalType> GetInterval(size_t iInterval)
   {
      return
         std::dynamic_pointer_cast<IntervalType>(DoGetInterval(iInterval));
   }
 
   template<typename IntervalType = const Interval>
   auto GetInterval(size_t iInterval) const
      -> std::enable_if_t<std::is_const_v<IntervalType>,
         std::shared_ptr<IntervalType>>
   {
      return std::dynamic_pointer_cast<IntervalType>(
         const_cast<ChannelGroup*>(this)->DoGetInterval(iInterval));
   }
 
 
   template<typename IntervalType>
   class IntervalIterator
      : public ValueIterator<
         std::shared_ptr<IntervalType>, std::bidirectional_iterator_tag
      >
   {
      using GroupType = std::conditional_t<std::is_const_v<IntervalType>,
         const ChannelGroup, ChannelGroup>;
   public:
      IntervalIterator() = default;
      IntervalIterator(GroupType *pGroup, size_t index)
         : mpGroup{ pGroup }, mIndex{ index }
      {}
 
      std::shared_ptr<IntervalType> operator *() const
      {
         if (!mpGroup || mIndex >= mpGroup->NIntervals())
            return {};
         return mpGroup->template GetInterval<IntervalType>(mIndex);
      }
 
      IntervalIterator &operator ++() { ++mIndex; return *this; }
      IntervalIterator operator ++(int)
         { auto copy{ *this }; operator ++(); return copy; }
 
      IntervalIterator &operator --() { --mIndex; return *this; }
      IntervalIterator operator --(int)
         { auto copy{ *this }; operator --(); return copy; }
 
      friend inline bool operator ==(IntervalIterator a, IntervalIterator b)
         { return a.mpGroup == b.mpGroup && a.mIndex == b.mIndex; }
      friend inline bool operator !=(IntervalIterator a, IntervalIterator b)
         { return !(a == b); }
 
   private:
      GroupType *mpGroup{};
      size_t mIndex{};
   };
 
   /*
      @pre `IsLeader()`
    */
   template<typename IntervalType = Interval>
   IteratorRange<IntervalIterator<IntervalType>> Intervals()
   {
      assert(IsLeader());
      return { { this, 0 }, { this, NIntervals() } };
   }
 
   /*
      @pre `IsLeader()`
    */
   template<typename IntervalType = const Interval>
   auto Intervals() const
      -> std::enable_if_t<std::is_const_v<IntervalType>,
         IteratorRange<IntervalIterator<IntervalType>>
      >
   {
      assert(IsLeader());
      return { { this, 0 }, { this, NIntervals() } };
   }
 
   // TODO remove this which is only used in assertions
   virtual bool IsLeader() const = 0;
 
   struct ChannelGroupData;
   using Attachments = ClientData::Site<
      ChannelGroupData, ClientData::Cloneable<>, ClientData::DeepCopying
   >;
 
   ChannelGroupData &GetGroupData();
   const ChannelGroupData &GetGroupData() const;
 
   ChannelGroupData *FindGroupData() { return mpGroupData.get(); }
   const ChannelGroupData *FindGroupData() const { return mpGroupData.get(); }
 
   void Init(const ChannelGroup &other);
 
   void DestroyGroupData();
 
   std::unique_ptr<ChannelGroupData> DetachGroupData();
 
   void AssignGroupData(std::unique_ptr<ChannelGroupData> pGroupData);
 
   // TODO wide wave tracks -- remove this
   enum class LinkType : int {
       None = 0, 
       // 1 - reserved for backward compatibility with projects generated by
       // older versions of Audacity
       Group = 2, 
       Aligned, 
   };
 
   // Structure describing data common to channels of a group of tracks
   // Should be deep-copyable (think twice before adding shared pointers!)
   struct CHANNEL_API ChannelGroupData : Attachments {
      using Attachments = ChannelGroup::Attachments;
      wxString mName;
      LinkType mLinkType{ LinkType::None };
      std::optional<double> mProjectTempo;
      bool mSelected{ false };
   };
 
protected:
 
   virtual std::shared_ptr<Channel> DoGetChannel(size_t iChannel) = 0;
 
 
   virtual std::shared_ptr<Interval> DoGetInterval(size_t iInterval) = 0;
 
private:
   // TODO wide wave tracks -- Make ChannelGroup itself the Site
   std::unique_ptr<ChannelGroupData> mpGroupData;
};
 
inline size_t Channel::NIntervals() const
{
   return GetChannelGroup().NIntervals();
}
 
template<typename IntervalType>
std::shared_ptr<IntervalType> Channel::GetInterval(size_t iInterval)
{
   return ReallyDoGetChannelGroup().GetInterval(iInterval)
      ->template GetChannel<IntervalType>(ReallyGetChannelIndex());
}
 
template<typename IntervalType>
auto Channel::GetInterval(size_t iInterval) const
   -> std::enable_if_t<std::is_const_v<IntervalType>,
      std::shared_ptr<IntervalType>>
{
   return ReallyDoGetChannelGroup().GetInterval(iInterval)
      ->template GetChannel<IntervalType>(ReallyGetChannelIndex());
}
#endif