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 "IteratorX.h"
 
 
class CHANNEL_API ChannelGroupInterval {
public:
   ChannelGroupInterval() = default;
 
   virtual ~ChannelGroupInterval();
 
   virtual double Start() const = 0;
   virtual double End() const = 0;
};
 
class CHANNEL_API ChannelInterval {
public:
   virtual ~ChannelInterval();
};
 
class ChannelGroup;
 
 
class CHANNEL_API WideChannelGroupInterval : public ChannelGroupInterval {
public:
   ~WideChannelGroupInterval() override;
 
 
   virtual size_t NChannels() const = 0;
 
 
   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;
};
 
class CHANNEL_API Channel
{
public:
   virtual ~Channel();
 
   ChannelGroup &GetChannelGroup();
   const ChannelGroup &GetChannelGroup() const;
 
   size_t GetChannelIndex() 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;
 
private:
};
 
using ChannelGroupAttachments = ClientData::Site<
   ChannelGroup, ClientData::Cloneable<>, ClientData::DeepCopying
>;
 
class CHANNEL_API ChannelGroup : public ChannelGroupAttachments
{
public:
   using Attachments = ChannelGroupAttachments;
 
   virtual ~ChannelGroup();
 
   double GetStartTime() const;
   double GetEndTime() const;
 
   void ShiftBy(double t) { MoveTo(GetStartTime() + t); }
 
   virtual void ShiftBy(double t0, double delta) = 0;
 
   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()
   {
      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>>
      >
   {
      return { { this, 0 }, { this, NChannels() } };
   }
 
   std::shared_ptr<Channel> NthChannel(size_t nChannel)
   {
      auto iter = Channels().begin();
      std::advance(iter, nChannel);
      return *iter;
   }
 
   std::shared_ptr<const Channel> NthChannel(size_t nChannel) const
   {
      auto iter = Channels().begin();
      std::advance(iter, nChannel);
      return *iter;
   }
 
   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{};
   };
 
   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() } };
   }
 
   enum class LinkType : int {
       None = 0, 
       // 1 - reserved for backward compatibility with projects generated by
       // older versions of Audacity
       Group = 2, 
       Aligned, 
   };
 
protected:
 
   virtual std::shared_ptr<Channel> DoGetChannel(size_t iChannel) = 0;
 
 
   virtual std::shared_ptr<Interval> DoGetInterval(size_t iInterval) = 0;
};
 
inline size_t Channel::NIntervals() const
{
   return GetChannelGroup().NIntervals();
}
 
template<typename IntervalType>
std::shared_ptr<IntervalType> Channel::GetInterval(size_t iInterval)
{
   return DoGetChannelGroup().GetInterval(iInterval)
      ->template GetChannel<IntervalType>(GetChannelIndex());
}
 
template<typename IntervalType>
auto Channel::GetInterval(size_t iInterval) const
   -> std::enable_if_t<std::is_const_v<IntervalType>,
      std::shared_ptr<IntervalType>>
{
   return DoGetChannelGroup().GetInterval(iInterval)
      ->template GetChannel<IntervalType>(GetChannelIndex());
}
#endif