From c09edbb18aadcea8106843068e2bc044262aec8c Mon Sep 17 00:00:00 2001
From: Paul Licameli <paul.licameli@audacityteam.org>
Date: Thu, 25 Apr 2019 16:23:51 -0400
Subject: [PATCH] Define and use const version of WaveTrack::GetAllClips

---
 src/UndoManager.cpp | 12 +++++------
 src/WaveClip.cpp    |  5 +++++
 src/WaveClip.h      |  1 +
 src/WaveTrack.h     | 50 +++++++++++++++++++++++++++++++++++++++------
 4 files changed, 56 insertions(+), 12 deletions(-)

diff --git a/src/UndoManager.cpp b/src/UndoManager.cpp
index 6797d3c2d..379ee8aaa 100644
--- a/src/UndoManager.cpp
+++ b/src/UndoManager.cpp
@@ -78,18 +78,18 @@ UndoManager::~UndoManager()
 
 namespace {
    SpaceArray::value_type
-   CalculateUsage(TrackList *tracks, Set *seen)
+   CalculateUsage(const TrackList &tracks, Set *seen)
    {
       SpaceArray::value_type result = 0;
 
       //TIMER_START( "CalculateSpaceUsage", space_calc );
-      for (auto wt : tracks->Any< WaveTrack >())
+      for (auto wt : tracks.Any< const WaveTrack >())
       {
          // Scan all clips within current track
          for(const auto &clip : wt->GetAllClips())
          {
             // Scan all blockfiles within current clip
-            BlockArray *blocks = clip->GetSequenceBlockArray();
+            auto blocks = clip->GetSequenceBlockArray();
             for (const auto &block : *blocks)
             {
                const auto &file = block.f;
@@ -137,12 +137,12 @@ void UndoManager::CalculateSpaceUsage()
    for (size_t nn = stack.size(); nn--;)
    {
       // Scan all tracks at current level
-      auto tracks = stack[nn]->state.tracks.get();
+      auto &tracks = *stack[nn]->state.tracks;
       space[nn] = CalculateUsage(tracks, &seen);
    }
 
-   mClipboardSpaceUsage = CalculateUsage
-      (AudacityProject::GetClipboardTracks(), nullptr);
+   mClipboardSpaceUsage = CalculateUsage(
+      *AudacityProject::GetClipboardTracks(), nullptr);
 
    //TIMER_STOP( space_calc );
 }
diff --git a/src/WaveClip.cpp b/src/WaveClip.cpp
index de96c02a0..7a1665218 100644
--- a/src/WaveClip.cpp
+++ b/src/WaveClip.cpp
@@ -416,6 +416,11 @@ BlockArray* WaveClip::GetSequenceBlockArray()
    return &mSequence->GetBlockArray();
 }
 
+const BlockArray* WaveClip::GetSequenceBlockArray() const
+{
+   return &mSequence->GetBlockArray();
+}
+
 double WaveClip::GetStartTime() const
 {
    // JS: mOffset is the minimum value and it is returned; no clipping to 0
diff --git a/src/WaveClip.h b/src/WaveClip.h
index 1bdc414c4..b1a2c51d1 100644
--- a/src/WaveClip.h
+++ b/src/WaveClip.h
@@ -238,6 +238,7 @@ public:
    Envelope* GetEnvelope() { return mEnvelope.get(); }
    const Envelope* GetEnvelope() const { return mEnvelope.get(); }
    BlockArray* GetSequenceBlockArray();
+   const BlockArray* GetSequenceBlockArray() const;
 
    // Get low-level access to the sequence. Whenever possible, don't use this,
    // but use more high-level functions inside WaveClip (or add them if you
diff --git a/src/WaveTrack.h b/src/WaveTrack.h
index def340ebe..20720f460 100644
--- a/src/WaveTrack.h
+++ b/src/WaveTrack.h
@@ -374,7 +374,7 @@ private:
    const WaveClipConstHolders &GetClips() const
       { return reinterpret_cast< const WaveClipConstHolders& >( mClips ); }
 
-   // Get access to all clips (in some unspecified sequence),
+   // Get mutative access to all clips (in some unspecified sequence),
    // including those hidden in cutlines.
    class AllClipsIterator
       : public ValueIterator< WaveClip * >
@@ -400,12 +400,12 @@ private:
       AllClipsIterator &operator ++ ();
 
       // Define == well enough to serve for loop termination test
-      friend bool operator ==
-         (const AllClipsIterator &a, const AllClipsIterator &b)
+      friend bool operator == (
+         const AllClipsIterator &a, const AllClipsIterator &b)
       { return a.mStack.empty() == b.mStack.empty(); }
 
-      friend bool operator !=
-         (const AllClipsIterator &a, const AllClipsIterator &b)
+      friend bool operator != (
+         const AllClipsIterator &a, const AllClipsIterator &b)
       { return !( a == b ); }
 
    private:
@@ -419,11 +419,49 @@ private:
       Stack mStack;
    };
 
+   // Get const access to all clips (in some unspecified sequence),
+   // including those hidden in cutlines.
+   class AllClipsConstIterator
+      : public ValueIterator< const WaveClip * >
+   {
+   public:
+      // Constructs an "end" iterator
+      AllClipsConstIterator () {}
+
+      // Construct a "begin" iterator
+      explicit AllClipsConstIterator( const WaveTrack &track )
+         : mIter{ const_cast< WaveTrack& >( track ) }
+      {}
+
+      const WaveClip *operator * () const
+      { return *mIter; }
+
+      AllClipsConstIterator &operator ++ ()
+      { ++mIter; return *this; }
+
+      // Define == well enough to serve for loop termination test
+      friend bool operator == (
+         const AllClipsConstIterator &a, const AllClipsConstIterator &b)
+      { return a.mIter == b.mIter; }
+
+      friend bool operator != (
+         const AllClipsConstIterator &a, const AllClipsConstIterator &b)
+      { return !( a == b ); }
+
+   private:
+      AllClipsIterator mIter;
+   };
+
    IteratorRange< AllClipsIterator > GetAllClips()
    {
       return { AllClipsIterator{ *this }, AllClipsIterator{ } };
    }
-
+   
+   IteratorRange< AllClipsConstIterator > GetAllClips() const
+   {
+      return { AllClipsConstIterator{ *this }, AllClipsConstIterator{ } };
+   }
+   
    // Create NEW clip and add it to this track. Returns a pointer
    // to the newly created clip.
    WaveClip* CreateClip();