Track.h

Go to the documentation of this file.

/*!********************************************************************
 
  Audacity: A Digital Audio Editor
 
  @file Track.h
  @brief declares abstract base class Track, TrackList, and iterators over TrackList
 
  Dominic Mazzoni
 
**********************************************************************/
#ifndef __AUDACITY_TRACK__
#define __AUDACITY_TRACK__
 
#include <algorithm>
#include <atomic>
#include <utility>
#include <list>
#include <optional>
#include <functional>
#include <wx/longlong.h>
 
#include "Channel.h"
#include "Observer.h"
// TrackAttachment needs to be a complete type for the Windows build, though
// not the others, so there is a nested include here:
#include "TrackAttachment.h"
#include "TypeEnumerator.h"
#include "TypeSwitch.h"
#include "XMLTagHandler.h"
 
#ifdef __WXMSW__
#pragma warning(disable:4284)
#endif
 
class wxTextFile;
class Track;
class AudacityProject;
 
using TrackArray = std::vector< Track* >;
 
class TrackList;
using TrackListHolder = std::shared_ptr<TrackList>;
 
using ListOfTracks = std::list< std::shared_ptr< Track > >;
 
using TrackNodePointer = ListOfTracks::iterator;
 
using ProgressReporter = std::function<void(double)>;
 
BEGIN_TYPE_ENUMERATION(TrackTypeTag)
 
 
 
#define ENUMERATE_TRACK_TYPE(T) ENUMERATE_TYPE(TrackTypeTag, T)
 
// forward declarations, so we can make them friends
template<typename T>
   std::enable_if_t< std::is_pointer_v<T>, T >
      track_cast(Track *track);
 
template<typename T>
   std::enable_if_t<
      std::is_pointer_v<T> &&
         std::is_const_v< std::remove_pointer_t< T > >,
      T
   >
      track_cast(const Track *track);
 
 
class TrackId
{
public:
   TrackId() : mValue(-1) {}
   explicit TrackId (long value) : mValue(value) {}
 
   bool operator == (const TrackId &other) const
   { return mValue == other.mValue; }
 
   bool operator != (const TrackId &other) const
   { return mValue != other.mValue; }
 
   // Define this in case you want to key a std::map on TrackId
   // The operator does not mean anything else
   bool operator <  (const TrackId &other) const
   { return mValue <  other.mValue; }
 
private:
   long mValue;
};
 
using AttachedTrackObjects = ClientData::Site<
   Track, TrackAttachment, ClientData::ShallowCopying, std::shared_ptr
>;
 
class TRACK_API Track /* not final */
   : public XMLTagHandler
   , public AttachedTrackObjects
   , public std::enable_shared_from_this<Track> // see SharedPointer()
   , public ChannelGroup
{
protected:
 
   struct ProtectedCreationArg{};
 
private:
 
   friend class TrackList;
 
 private:
   TrackId mId; 
 
 protected:
   std::weak_ptr<TrackList> mList; 
   TrackNodePointer mNode{};
 
 public:
 
   using AttachedObjects = ::AttachedTrackObjects;
 
   TrackId GetId() const { return mId; }
 private:
   void SetId( TrackId id ) { mId = id; }
 public:
 
   // Given a bare pointer, find a shared_ptr.  Undefined results if the track
   // is not yet managed by a shared_ptr.  Undefined results if the track is
   // not really of the subclass.  (That is, trusts the caller and uses static
   // not dynamic casting.)
   template<typename Subclass = Track>
   inline std::shared_ptr<Subclass> SharedPointer()
   {
      // shared_from_this is injected into class scope by base class
      // std::enable_shared_from_this<Track>
      return std::static_pointer_cast<Subclass>( shared_from_this() );
   }
 
   template<typename Subclass = const Track>
   inline auto SharedPointer() const ->
      std::enable_if_t<
         std::is_const_v<Subclass>, std::shared_ptr<Subclass>
      >
   {
      // shared_from_this is injected into class scope by base class
      // std::enable_shared_from_this<Track>
      return std::static_pointer_cast<Subclass>( shared_from_this() );
   }
 
   // Static overloads of SharedPointer for when the pointer may be null
   template<typename Subclass = Track>
   static inline std::shared_ptr<Subclass> SharedPointer( Track *pTrack )
   { return pTrack ? pTrack->SharedPointer<Subclass>() : nullptr; }
 
   template<typename Subclass = const Track>
   static inline std::shared_ptr<Subclass> SharedPointer( const Track *pTrack )
   { return pTrack ? pTrack->SharedPointer<Subclass>() : nullptr; }
 
 
   struct TypeNames {
      wxString info; 
      wxString property; 
      TranslatableString name; 
   };
   struct TypeInfo {
      TypeNames names;
      bool concrete = false;
      const TypeInfo *pBaseInfo = nullptr;
 
      bool IsBaseOf(const TypeInfo &other) const
      {
         for (auto pInfo = &other;
              pInfo; pInfo = pInfo->pBaseInfo)
            if (this == pInfo)
               return true;
         return false;
      }
   };
   virtual const TypeInfo &GetTypeInfo() const = 0;
   static const TypeInfo &ClassTypeInfo();
   virtual const TypeNames &GetTypeNames() const
   { return GetTypeInfo().names; }
 
   virtual bool SupportsBasicEditing() const;
 
   using Holder = std::shared_ptr<Track>;
 
 
   virtual Holder PasteInto(AudacityProject &project, TrackList &list)
      const = 0;
 
public:
 
   virtual bool LinkConsistencyFix(bool doFix = true);
 
   bool LinkConsistencyCheck()
   { return const_cast<Track*>(this)->LinkConsistencyFix(false); }
 
   bool HasOwner() const { return static_cast<bool>(GetOwner());}
 
   std::shared_ptr<TrackList> GetOwner() const { return mList.lock(); }
 
   LinkType GetLinkType() const noexcept;
 
protected:
 
   void SetLinkType(LinkType linkType, bool completeList = true);
 
private:
   void DoSetLinkType(LinkType linkType, bool completeList = true);
 
   Track* GetLinkedTrack() const;
   bool HasLinkedTrack() const noexcept;
 
   TrackNodePointer GetNode() const;
   void SetOwner(
      const std::weak_ptr<TrackList> &list, TrackNodePointer node);
 
 public:
 
   Track();
   Track(const Track &orig, ProtectedCreationArg&&);
   Track& operator =(const Track &orig) = delete;
 
   virtual ~ Track();
 
   void Init(const Track &orig);
 
   static void CopyAttachments(Track &dst, const Track &src, bool deep);
 
   struct DuplicateOptions {
      DuplicateOptions()
         : shallowCopyAttachments{ false }
         , backup{ false }
      {}
 
      bool shallowCopyAttachments;
 
      bool backup;
 
      // Supporting chain-call idiom
      DuplicateOptions ShallowCopyAttachments() &&
      { shallowCopyAttachments = true; return std::move(*this); }
 
      // Supporting chain-call idiom
      DuplicateOptions Backup() &&
      { backup = true; return std::move(*this); }
   };
 
   virtual Holder Duplicate(DuplicateOptions = {}) const;
 
   void ReparentAllAttachments();
 
   const wxString &GetName() const;
   void SetName( const wxString &n );
 
   bool GetSelected() const;
   virtual void SetSelected(bool s);
 
public:
 
 
   virtual Holder Cut(double t0, double t1) = 0;
 
 
   virtual Holder Copy(double t0, double t1, bool forClipboard = true)
      const = 0;
 
   virtual void Clear(double t0, double t1) = 0;
 
 
   virtual void Paste(double t, const Track &src) = 0;
 
   virtual void SyncLockAdjust(double oldT1, double newT1);
 
   // May assume precondition: t0 <= t1
   virtual void
   Silence(double t0, double t1, ProgressReporter reportProgress = {}) = 0;
 
   virtual void InsertSilence(double t, double len) = 0;
 
private:
 
   virtual Holder Clone(bool backup) const = 0;
 
   template<typename T>
      friend std::enable_if_t< std::is_pointer_v<T>, T >
         track_cast(Track *track);
   template<typename T>
      friend std::enable_if_t<
         std::is_pointer_v<T> &&
            std::is_const_v< std::remove_pointer_t< T > >,
         T
      >
         track_cast(const Track *track);
 
public:
   bool SameKindAs(const Track &track) const
      { return &GetTypeInfo() == &track.GetTypeInfo(); }
 
   template<typename R = void, typename ...Functions>
   R TypeSwitch(const Functions &...functions)
   {
      struct Here : TrackTypeTag {};
      // List more derived classes later
      using TrackTypes =
         typename TypeEnumerator::CollectTypes<TrackTypeTag, Here>::type;
      return TypeSwitch::VDispatch<R, TrackTypes>(*this, functions...);
   }
 
   template<typename R = void, typename ...Functions>
   R TypeSwitch(const Functions &...functions) const
   {
      struct Here : TrackTypeTag {};
      // List more derived classes later
      using namespace TypeList;
      using TrackTypes = Map_t<Fn<std::add_const_t>,
         typename TypeEnumerator::CollectTypes<TrackTypeTag, Here>::type>;
      return TypeSwitch::VDispatch<R, TrackTypes>(*this, functions...);
   }
 
   // XMLTagHandler callback methods -- NEW virtual for writing
   virtual void WriteXML(XMLWriter &xmlFile) const = 0;
 
 
   virtual std::optional<TranslatableString> GetErrorOpening() const;
 
   // Send a notification to subscribers when state of the track changes
   // To do: define values for the argument to distinguish different parts
   // of the state
   void Notify(bool allChannels, int code = -1);
 
   // An always-true predicate useful for defining iterators
   bool Any() const;
 
   // Frequently useful operands for + and -
   bool IsSelected() const;
   bool IsLeader() const;
 
   // Cause this track and following ones in its TrackList to adjust
   void AdjustPositions();
 
   // Serialize, not with tags of its own, but as attributes within a tag.
   void WriteCommonXMLAttributes(
      XMLWriter &xmlFile, bool includeNameAndSelected = true) const;
 
   // Return true iff the attribute is recognized.
   bool HandleCommonXMLAttribute(const std::string_view& attr, const XMLAttributeValueView& valueView);
 
private:
   void CopyGroupProperties(const Track &other);
 
   wxString mName;
   // This is important only during loading of files
   LinkType mLinkType{ LinkType::None };
   bool mSelected{ false };
};
 
ENUMERATE_TRACK_TYPE(Track);
 
template<typename Base = Track>
class UniqueChannelTrack
   : public Base
   , public Channel
{
public:
   using Base::Base;
   size_t NChannels() const override { return 1; }
   std::shared_ptr<Channel> DoGetChannel(size_t iChannel) override
   {
      if (iChannel == 0) {
         // Use aliasing constructor of std::shared_ptr
         Channel *alias = this;
         return { this->shared_from_this(), alias };
      }
      return {};
   }
protected:
   ChannelGroup &DoGetChannelGroup() const override {
      const Track &track = *this;
      return const_cast<Track&>(track);
   }
};
 
 
template<typename T>
   inline std::enable_if_t< std::is_pointer_v<T>, T >
      track_cast(Track *track)
{
   using BareType = std::remove_pointer_t< T >;
   if (track &&
       BareType::ClassTypeInfo().IsBaseOf(track->GetTypeInfo() ))
      return reinterpret_cast<T>(track);
   else
      return nullptr;
}
 
template<typename T>
   inline std::enable_if_t<
      std::is_pointer_v<T> && std::is_const_v< std::remove_pointer_t< T > >,
      T
   >
      track_cast(const Track *track)
{
   using BareType = std::remove_pointer_t< T >;
   if (track &&
       BareType::ClassTypeInfo().IsBaseOf(track->GetTypeInfo() ))
      return reinterpret_cast<T>(track);
   else
      return nullptr;
}
 
template < typename TrackType > struct TrackIterRange;
 
 
template <
   typename TrackType
> class TrackIter
   : public ValueIterator< TrackType *, std::bidirectional_iterator_tag >
{
public:
   using FunctionType = std::function< bool(
      std::add_pointer_t< std::add_const_t< std::remove_pointer_t<TrackType> > >
   ) >;
 
   TrackIter(
         TrackNodePointer begin, 
         TrackNodePointer iter, 
         TrackNodePointer end, 
         FunctionType pred = {} 
   )
      : mBegin( begin ), mIter( iter ), mEnd( end )
      , mPred( std::move(pred) )
   {
      // Establish the class invariant
      if (this->mIter != this->mEnd && !this->valid())
         this->operator ++ ();
   }
 
 
   template < typename Predicate2 >
   TrackIter Filter( const Predicate2 &pred2 ) const
   {
      return { this->mBegin, this->mIter, this->mEnd, pred2 };
   }
 
 
   template < typename TrackType2 >
      auto Filter() const
         -> std::enable_if_t<
            std::is_base_of_v< TrackType, TrackType2 > &&
               (!std::is_const_v<TrackType> ||
                 std::is_const_v<TrackType2>),
            TrackIter< TrackType2 >
         >
   {
      return { this->mBegin, this->mIter, this->mEnd, this->mPred };
   }
 
   const FunctionType &GetPredicate() const
   { return this->mPred; }
 
 
   TrackIter &operator ++ ()
   {
      // Maintain the class invariant
      if (this->mIter != this->mEnd) do
         ++this->mIter;
      while (this->mIter != this->mEnd && !this->valid() );
      return *this;
   }
 
   TrackIter operator ++ (int)
   {
      TrackIter result { *this };
      this-> operator ++ ();
      return result;
   }
 
 
   TrackIter &operator -- ()
   {
      // Maintain the class invariant
      do {
         if (this->mIter == this->mBegin)
            // Go circularly
            this->mIter = this->mEnd;
         else
            --this->mIter;
      } while (this->mIter != this->mEnd && !this->valid() );
      return *this;
   }
 
   TrackIter operator -- (int)
   {
      TrackIter result { *this };
      this->operator -- ();
      return result;
   }
 
 
   TrackType *operator * () const
   {
      if (this->mIter == this->mEnd)
         return nullptr;
      else
         // Other methods guarantee that the cast is correct
         // (provided no operations on the TrackList invalidated
         // underlying iterators or replaced the tracks there)
         return static_cast< TrackType * >( &**this->mIter );
   }
 
   TrackIter advance(
      long amount 
   ) const
   {
      auto copy = *this;
      std::advance( copy, amount );
      return copy;
   }
 
   friend inline bool operator == (TrackIter a, TrackIter b)
   {
      // Assume the predicate is not stateful.  Just compare the iterators.
      return
         a.mIter == b.mIter
         // Assume this too:
         // && a.mBegin == b.mBegin && a.mEnd == b.mEnd
      ;
   }
 
   friend inline bool operator != (TrackIter a, TrackIter b)
   {
      return !(a == b);
   }
 
private:
   bool valid() const
   {
      // assume mIter != mEnd
      const auto pTrack = track_cast< TrackType * >( &**this->mIter );
      if (!pTrack)
         return false;
      return !this->mPred || this->mPred( pTrack );
   }
 
   friend TrackIterRange< TrackType >;
 
   TrackNodePointer
      mBegin, 
      mIter, 
      mEnd; 
   FunctionType mPred; 
};
 
template <
   typename TrackType // Track or a subclass, maybe const-qualified
> struct TrackIterRange
   : public IteratorRange< TrackIter< TrackType > >
{
   TrackIterRange
      ( const TrackIter< TrackType > &begin,
        const TrackIter< TrackType > &end )
         : IteratorRange< TrackIter< TrackType > >
            ( begin, end )
   {}
 
   // Conjoin the filter predicate with another predicate
   // Read + as "and"
   template< typename Predicate2 >
      TrackIterRange operator + ( const Predicate2 &pred2 ) const
   {
      const auto &pred1 = this->first.GetPredicate();
      using Function = typename TrackIter<TrackType>::FunctionType;
      const auto &newPred = pred1
         ? Function{ [=] (typename Function::argument_type track) {
            return pred1(track) && pred2(track);
         } }
         : Function{ pred2 };
      return {
         this->first.Filter( newPred ),
         this->second.Filter( newPred )
      };
   }
 
   // Specify the added conjunct as a pointer to member function
   // Read + as "and"
   template< typename R, typename C >
      TrackIterRange operator + ( R ( C ::* pmf ) () const ) const
   {
      return this->operator + ( std::mem_fn( pmf ) );
   }
 
   // Conjoin the filter predicate with the negation of another predicate
   // Read - as "and not"
   template< typename Predicate2 >
      TrackIterRange operator - ( const Predicate2 &pred2 ) const
   {
      using ArgumentType =
         typename TrackIterRange::iterator::FunctionType::argument_type;
      auto neg = [=] (ArgumentType track) { return !pred2( track ); };
      return this->operator + ( neg );
   }
 
   // Specify the negated conjunct as a pointer to member function
   // Read - as "and not"
   template< typename R, typename C >
      TrackIterRange operator - ( R ( C ::* pmf ) () const ) const
   {
      return this->operator + ( std::not1( std::mem_fn( pmf ) ) );
   }
 
   template< typename TrackType2 >
      TrackIterRange< TrackType2 > Filter() const
   {
      return {
         this-> first.template Filter< TrackType2 >(),
         this->second.template Filter< TrackType2 >()
      };
   }
 
   TrackIterRange StartingWith( const Track *pTrack ) const
   {
      auto newBegin = this->find( pTrack );
      // More careful construction is needed so that the independent
      // increment and decrement of each iterator in the NEW pair
      // has the expected behavior at boundaries of the range
      return {
         { newBegin.mIter, newBegin.mIter,    this->second.mEnd,
           this->first.GetPredicate() },
         { newBegin.mIter, this->second.mIter, this->second.mEnd,
           this->second.GetPredicate() }
      };
   }
 
   TrackIterRange EndingAfter( const Track *pTrack ) const
   {
      const auto newEnd = this->reversal().find( pTrack ).base();
      // More careful construction is needed so that the independent
      // increment and decrement of each iterator in the NEW pair
      // has the expected behavior at boundaries of the range
      return {
         { this->first.mBegin, this->first.mIter, newEnd.mIter,
           this->first.GetPredicate() },
         { this->first.mBegin, newEnd.mIter,      newEnd.mIter,
           this->second.GetPredicate() }
      };
   }
 
   // Exclude one given track
   TrackIterRange Excluding ( const TrackType *pExcluded ) const
   {
      return this->operator - (
         [=](const Track *pTrack){ return pExcluded == pTrack; } );
   }
 
   template< typename ...Functions >
   void Visit(const Functions &...functions)
   {
      for (auto track : *this)
         track->TypeSwitch(functions...);
   }
 
 
   template< typename Flag, typename ...Functions >
   void VisitWhile(Flag &flag, const Functions &...functions)
   {
      if ( flag ) for (auto track : *this) {
         track->TypeSwitch(functions...);
         if (!flag)
            break;
      }
   }
};
 
 
struct TrackListEvent
{
   enum Type {
      SELECTION_CHANGE,
 
      TRACK_DATA_CHANGE,
 
 
      PERMUTED,
 
      RESIZING,
 
      ADDITION,
 
 
      DELETION,
   };
 
   TrackListEvent( Type type,
      const std::weak_ptr<Track> &pTrack = {}, int extra = -1)
      : mType{ type }
      , mpTrack{ pTrack }
      , mExtra{ extra }
   {}
 
   TrackListEvent( const TrackListEvent& ) = default;
 
   const Type mType;
   const std::weak_ptr<Track> mpTrack;
   const int mExtra;
};
 
class TRACK_API TrackList final
   : public Observer::Publisher<TrackListEvent>
   , private ListOfTracks
   , public std::enable_shared_from_this<TrackList>
   , public ClientData::Base
{
   // privatize this, make you use Add instead:
   using ListOfTracks::push_back;
 
   // privatize this, make you use Swap instead:
   using ListOfTracks::swap;
 
   // Disallow copy
   TrackList(const TrackList &that) = delete;
   TrackList &operator= (const TrackList&) = delete;
 
   // No need for move, disallow it
   TrackList(TrackList &&that) = delete;
   TrackList& operator= (TrackList&&) = delete;
 
   void clear() = delete;
 
 public:
   static TrackList &Get( AudacityProject &project );
   static const TrackList &Get( const AudacityProject &project );
 
   // Create an empty TrackList
   // Don't call directly -- use Create() instead
   explicit TrackList( AudacityProject *pOwner );
 
   // Create an empty TrackList
   static TrackListHolder Create(AudacityProject *pOwner);
 
   void Swap(TrackList &that);
 
   // Destructor
   virtual ~TrackList();
 
   // Find the owning project, which may be null
   AudacityProject *GetOwner() { return mOwner; }
   const AudacityProject *GetOwner() const { return mOwner; }
 
   wxString MakeUniqueTrackName(const wxString& baseTrackName) const;
 
   // Iteration
 
   // Hide the inherited begin() and end()
   using iterator = TrackIter<Track>;
   using const_iterator = TrackIter<const Track>;
 
   using value_type = Track *;
   iterator begin() { return Any().begin(); }
   iterator end() { return Any().end(); }
   const_iterator begin() const { return Any().begin(); }
   const_iterator end() const { return Any().end(); }
   const_iterator cbegin() const { return begin(); }
   const_iterator cend() const { return end(); }
 
   // Reverse iteration
   using reverse_iterator = std::reverse_iterator<iterator>;
   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
   reverse_iterator rbegin() { return Any().rbegin(); }
   reverse_iterator rend() { return Any().rend(); }
   const_reverse_iterator rbegin() const { return Any().rbegin(); }
   const_reverse_iterator rend() const { return Any().rend(); }
   const_reverse_iterator crbegin() const { return rbegin(); }
   const_reverse_iterator crend() const { return rend(); }
 
   TrackIter<Track> DoFind(Track *pTrack);
 
   // From a track, get an iterator into its owning TrackList.  If it is not
   // owned, get a default constructed iterator.
   TrackIter<Track> Find(Track *pTrack);
 
   TrackIter<const Track> Find(const Track *pTrack) const
   {
      return const_cast<TrackList*>(this)->
         Find(const_cast<Track*>(pTrack)).Filter<const Track>();
   }
 
 
private:
   iterator Begin() { return Tracks<Track>().begin(); }
   iterator End() { return Tracks<Track>().end(); }
 
   const_iterator Begin() const { return Tracks<const Track>().begin(); }
   const_iterator End() const { return Tracks<const Track>().end(); }
 
public:
   template < typename TrackType = Track >
      auto Any()
         -> TrackIterRange< TrackType >
   {
      return Tracks< TrackType >( &Track::IsLeader );
   }
 
   template < typename TrackType = const Track >
      auto Any() const
         -> std::enable_if_t< std::is_const_v<TrackType>,
            TrackIterRange< TrackType >
         >
   {
      return Tracks< TrackType >( &Track::IsLeader );
   }
 
 
   template <typename TrackType = Track>
   auto Selected() -> TrackIterRange<TrackType>
   {
      return Tracks<TrackType>(&Track::IsSelected);
   }
 
   template <typename TrackType = const Track>
   auto Selected() const
      -> std::enable_if_t<std::is_const_v<TrackType>, TrackIterRange<TrackType>>
   {
      return Tracks<TrackType>(&Track::IsSelected);
   }
 
 
   template<typename TrackType>
      static auto SingletonRange( TrackType *pTrack )
         -> TrackIterRange< TrackType >
   {
      return pTrack->GetOwner()->template Tracks<TrackType>()
         .StartingWith( pTrack ).EndingAfter( pTrack );
   }
 
 
private:
   Track *DoAddToHead(const std::shared_ptr<Track> &t);
   Track *DoAdd(const std::shared_ptr<Track> &t, bool assignIds);
 
   template< typename TrackType, typename InTrackType >
      static TrackIterRange< TrackType >
         Channels_( TrackIter< InTrackType > iter1 )
   {
      if (*iter1) {
         return {
            iter1.Filter( &Track::Any )
               .template Filter<TrackType>(),
            (++iter1).Filter( &Track::Any )
               .template Filter<TrackType>()
         };
      }
      else
         // empty range
         return {
            iter1.template Filter<TrackType>(),
            iter1.template Filter<TrackType>()
         };
   }
 
public:
   // Find an iterator range of channels including the given track.
   template< typename TrackType >
      static auto Channels( TrackType *pTrack )
         -> TrackIterRange< TrackType >
   {
      return Channels_<TrackType>(pTrack->GetOwner()->Find(pTrack));
   }
 
   friend class Track;
 
   void Insert(
      const Track* before, const Track::Holder &pSrc, bool assignIds = false);
 
   void Permute(const std::vector<Track *> &tracks);
 
   Track *FindById( TrackId id );
 
   template<typename TrackKind>
      TrackKind *AddToHead( const std::shared_ptr<TrackKind> &t )
         { return static_cast<TrackKind*>(DoAddToHead(t)); }
 
   template<typename TrackKind>
      TrackKind *Add(const std::shared_ptr<TrackKind> &t,
         bool assignIds = true)
            { return static_cast<TrackKind*>(DoAdd(t, assignIds)); }
 
   Track::Holder ReplaceOne(Track &t, TrackList &&with);
 
   Track::Holder Remove(Track &track);
 
   void Clear(bool sendEvent = true);
 
   bool CanMoveUp(Track &t) const;
   bool CanMoveDown(Track &t) const;
 
   bool MoveUp(Track &t);
   bool MoveDown(Track &t);
   bool Move(Track &t, bool up) { return up ? MoveUp(t) : MoveDown(t); }
 
   // Return non-null only if the weak pointer is not, and the track is
   // owned by this list; constant time.
   template <typename Subclass>
   std::shared_ptr<Subclass> Lock(const std::weak_ptr<Subclass> &wTrack)
   {
      auto pTrack = wTrack.lock();
      if (pTrack) {
         auto pList = pTrack->mList.lock();
         if (pTrack && this == pList.get())
            return pTrack;
      }
      return {};
   }
 
   bool empty() const;
   size_t Size() const { return Any().size(); }
 
   double GetStartTime() const;
   double GetEndTime() const;
 
 
   static TrackListHolder Temporary(AudacityProject *pProject,
      const Track::Holder &pTrack = {});
 
   static void AssignUniqueId(const Track::Holder &track);
 
 
   void Append(TrackList &&list, bool assignIds = true);
 
   void AppendOne(TrackList &&list);
 
   Track::Holder DetachFirst();
 
private:
   using ListOfTracks::size;
 
   // Visit all tracks satisfying a predicate, mutative access
   template <
      typename TrackType = Track,
      typename Pred =
         typename TrackIterRange< TrackType >::iterator::FunctionType
   >
      auto Tracks( const Pred &pred = {} )
         -> TrackIterRange< TrackType >
   {
      auto b = getBegin(), e = getEnd();
      return { { b, b, e, pred }, { b, e, e, pred } };
   }
 
   // Visit all tracks satisfying a predicate, const access
   template <
      typename TrackType = const Track,
      typename Pred =
         typename TrackIterRange< TrackType >::iterator::FunctionType
   >
      auto Tracks( const Pred &pred = {} ) const
         -> std::enable_if_t< std::is_const_v<TrackType>,
            TrackIterRange< TrackType >
         >
   {
      auto b = const_cast<TrackList*>(this)->getBegin();
      auto e = const_cast<TrackList*>(this)->getEnd();
      return { { b, b, e, pred }, { b, e, e, pred } };
   }
 
   Track *GetPrev(Track &, bool linked = false) const;
   Track *GetNext(Track &, bool linked = false) const;
 
   template < typename TrackType >
      TrackIter< TrackType >
         MakeTrackIterator( TrackNodePointer iter ) const
   {
      auto b = const_cast<TrackList*>(this)->getBegin();
      auto e = const_cast<TrackList*>(this)->getEnd();
      return { b, iter, e };
   }
 
   template < typename TrackType >
      TrackIter< TrackType >
         EndIterator() const
   {
      auto e = const_cast<TrackList*>(this)->getEnd();
      return { e, e, e };
   }
 
   TrackIterRange< Track > EmptyRange() const;
 
   bool isNull(TrackNodePointer p) const { return p == ListOfTracks::end(); }
   TrackNodePointer getEnd() const
   { return const_cast<TrackList*>(this)->ListOfTracks::end(); }
   TrackNodePointer getBegin() const
   { return const_cast<TrackList*>(this)->ListOfTracks::begin(); }
 
   TrackNodePointer getNext(TrackNodePointer p) const
   {
      if ( isNull(p) )
         return p;
      auto q = p;
      ++q;
      return q;
   }
 
   TrackNodePointer getPrev(TrackNodePointer p) const
   {
      if (p == getBegin())
         return getEnd();
      else {
         auto q = p;
         --q;
         return q;
      }
   }
 
   void RecalcPositions(TrackNodePointer node);
   void QueueEvent(TrackListEvent event);
   void SelectionEvent(Track &track);
   void PermutationEvent(TrackNodePointer node);
   void DataEvent(
      const std::shared_ptr<Track> &pTrack, bool allChannels, int code );
   void DeletionEvent(std::weak_ptr<Track> node, bool duringReplace);
   void AdditionEvent(TrackNodePointer node);
   void ResizingEvent(TrackNodePointer node);
 
   void SwapNodes(TrackNodePointer s1, TrackNodePointer s2);
 
   // Nondecreasing during the session.
   // Nonpersistent.
   // Used to assign ids to added tracks.
   static long sCounter;
 
   AudacityProject *mOwner;
 
   bool mAssignsIds{ true };
};
 
#endif