Rename IndexRange member functions

8 files changed, 77 insertions, 79 deletions

diff --git a/src/analyzer/analyzerqueue.cpp b/src/analyzer/analyzerqueue.cpp
index 13ebe0569e..47ac7a0e9d 100644
--- a/src/analyzer/analyzerqueue.cpp
+++ b/src/analyzer/analyzerqueue.cpp
@@ -191,7 +191,7 @@ bool AnalyzerQueue::doAnalysis(
         ScopedTimer t("AnalyzerQueue::doAnalysis block");
 
         const auto inputFrameIndexRange =
-                remainingFrames.cutFrontRange(
+                remainingFrames.splitAndShrinkFront(
                         math_min(kAnalysisFramesPerBlock, remainingFrames.length()));
         DEBUG_ASSERT(!inputFrameIndexRange.empty());
         const auto readableSampleFrames =
diff --git a/src/engine/cachingreader.cpp b/src/engine/cachingreader.cpp
index 514c235405..2764e5c96c 100644
--- a/src/engine/cachingreader.cpp
+++ b/src/engine/cachingreader.cpp
@@ -294,7 +294,7 @@ SINT CachingReader::read(SINT startSample, SINT numSamples, bool reverse, CSAMPL
                 buffer += prerollSamples;
             }
             samplesRemaining -= prerollSamples;
-            remainingFrameIndexRange.dropFrontRange(prerollFrames);
+            remainingFrameIndexRange.shrinkFront(prerollFrames);
         }
 
         // Read the actual samples from the audio source into the
@@ -397,7 +397,7 @@ SINT CachingReader::read(SINT startSample, SINT numSamples, bool reverse, CSAMPL
                         buffer += paddingSamples;
                     }
                     samplesRemaining -= paddingSamples;
-                    remainingFrameIndexRange.dropFrontRange(paddingFrameIndexRange.length());
+                    remainingFrameIndexRange.shrinkFront(paddingFrameIndexRange.length());
                 }
                 const SINT chunkSamples =
                         CachingReaderChunk::frames2samples(bufferedFrameIndexRange.length());
@@ -406,7 +406,7 @@ SINT CachingReader::read(SINT startSample, SINT numSamples, bool reverse, CSAMPL
                 }
                 DEBUG_ASSERT(samplesRemaining >= chunkSamples);
                 samplesRemaining -= chunkSamples;
-                remainingFrameIndexRange.dropFrontRange(bufferedFrameIndexRange.length());
+                remainingFrameIndexRange.shrinkFront(bufferedFrameIndexRange.length());
             }
         }
     }
diff --git a/src/engine/cachingreaderworker.cpp b/src/engine/cachingreaderworker.cpp
index 292340702b..ca98ea82a4 100644
--- a/src/engine/cachingreaderworker.cpp
+++ b/src/engine/cachingreaderworker.cpp
@@ -59,16 +59,16 @@ ReaderStatusUpdate CachingReaderWorker::processReadRequest(
         if (bufferedFrameIndexRange.empty()) {
             // Adjust upper bound: Consider all audio data following
             // the read position until the end as unreadable
-            m_readableFrameIndexRange.dropBackRange(m_readableFrameIndexRange.end() - chunkFrameIndexRange.start());
+            m_readableFrameIndexRange.shrinkBack(m_readableFrameIndexRange.end() - chunkFrameIndexRange.start());
             status = CHUNK_READ_INVALID; // not EOF (see above)
         } else {
             // Adjust lower bound of readable audio data
             if (chunkFrameIndexRange.start() < bufferedFrameIndexRange.start()) {
-                m_readableFrameIndexRange.dropFrontRange(bufferedFrameIndexRange.start() - m_readableFrameIndexRange.start());
+                m_readableFrameIndexRange.shrinkFront(bufferedFrameIndexRange.start() - m_readableFrameIndexRange.start());
             }
             // Adjust upper bound of readable audio data
             if (chunkFrameIndexRange.end() > bufferedFrameIndexRange.end()) {
-                m_readableFrameIndexRange.dropBackRange(m_readableFrameIndexRange.end() - bufferedFrameIndexRange.end());
+                m_readableFrameIndexRange.shrinkBack(m_readableFrameIndexRange.end() - bufferedFrameIndexRange.end());
             }
         }
         kLogger.warning()
diff --git a/src/sources/audiosource.cpp b/src/sources/audiosource.cpp
index 9d1dde66a4..ded3e13950 100644
--- a/src/sources/audiosource.cpp
+++ b/src/sources/audiosource.cpp
@@ -97,7 +97,7 @@ WritableSampleFrames AudioSource::clampWritableSampleFrames(
                 << "into writable sample frames"
                 << writableFrameIndexRange;
         writableFrameIndexRange =
-                writableFrameIndexRange.cutFrontRange(
+                writableFrameIndexRange.splitAndShrinkFront(
                         samples2frames(sampleFrames.sampleBuffer().size()));
         kLogger.warning()
                 << "Reduced writable sample frames"
@@ -106,7 +106,7 @@ WritableSampleFrames AudioSource::clampWritableSampleFrames(
     DEBUG_ASSERT(readableFrameIndexRange.start() >= writableFrameIndexRange.start());
     const SINT writableFrameOffset =
             readableFrameIndexRange.start() - writableFrameIndexRange.start();
-    writableFrameIndexRange.dropFrontRange(writableFrameOffset);
+    writableFrameIndexRange.shrinkFront(writableFrameOffset);
     return WritableSampleFrames(
             writableFrameIndexRange,
             SampleBuffer::WritableSlice(
diff --git a/src/test/indexrange_test.cpp b/src/test/indexrange_test.cpp
index e867ad3a8b..028514a76b 100644
--- a/src/test/indexrange_test.cpp
+++ b/src/test/indexrange_test.cpp
@@ -83,75 +83,75 @@ TEST_F(IndexRangeTest, startend) {
     EXPECT_EQ(1, IndexRange::between(1, 1).end());
 }
 
-TEST_F(IndexRangeTest, dropFrontRange) {
+TEST_F(IndexRangeTest, shrinkFront) {
     auto r1 = IndexRange::between(-4, 9);
-    r1.dropFrontRange(3);
+    r1.shrinkFront(3);
     EXPECT_EQ(IndexRange::between(-1, 9), r1);
-    r1.dropFrontRange(0);
+    r1.shrinkFront(0);
     EXPECT_EQ(IndexRange::between(-1, 9), r1);
-    r1.dropFrontRange(r1.length());
+    r1.shrinkFront(r1.length());
     EXPECT_TRUE(r1.empty());
 
     auto r2 = IndexRange::between(9, -4);
-    r2.dropFrontRange(3);
+    r2.shrinkFront(3);
     EXPECT_EQ(IndexRange::between(6, -4), r2);
-    r2.dropFrontRange(0);
+    r2.shrinkFront(0);
     EXPECT_EQ(IndexRange::between(6, -4), r2);
-    r2.dropFrontRange(r2.length());
+    r2.shrinkFront(r2.length());
     EXPECT_TRUE(r2.empty());
 }
 
-TEST_F(IndexRangeTest, cutFrontRange) {
+TEST_F(IndexRangeTest, splitAndShrinkFront) {
     auto r1 = IndexRange::between(-4, 9);
-    EXPECT_EQ(IndexRange::between(-4, -1), r1.cutFrontRange(3));
+    EXPECT_EQ(IndexRange::between(-4, -1), r1.splitAndShrinkFront(3));
     EXPECT_EQ(IndexRange::between(-1, 9), r1);
-    EXPECT_TRUE(r1.cutFrontRange(0).empty());
+    EXPECT_TRUE(r1.splitAndShrinkFront(0).empty());
     EXPECT_EQ(IndexRange::between(-1, 9), r1);
-    EXPECT_EQ(IndexRange::between(-1, 9), r1.cutFrontRange(r1.length()));
+    EXPECT_EQ(IndexRange::between(-1, 9), r1.splitAndShrinkFront(r1.length()));
     EXPECT_TRUE(r1.empty());
 
     auto r2 = IndexRange::between(9, -4);
-    EXPECT_EQ(IndexRange::between(9, 6), r2.cutFrontRange(3));
+    EXPECT_EQ(IndexRange::between(9, 6), r2.splitAndShrinkFront(3));
     EXPECT_EQ(IndexRange::between(6, -4), r2);
-    EXPECT_TRUE(r2.cutFrontRange(0).empty());
+    EXPECT_TRUE(r2.splitAndShrinkFront(0).empty());
     EXPECT_EQ(IndexRange::between(6, -4), r2);
-    EXPECT_EQ(IndexRange::between(6, -4), r2.cutFrontRange(r2.length()));
+    EXPECT_EQ(IndexRange::between(6, -4), r2.splitAndShrinkFront(r2.length()));
     EXPECT_TRUE(r2.empty());
 }
 
-TEST_F(IndexRangeTest, dropBackRange) {
+TEST_F(IndexRangeTest, shrinkBack) {
     auto r1 = IndexRange::between(-4, 9);
-    r1.dropBackRange(3);
+    r1.shrinkBack(3);
     EXPECT_EQ(IndexRange::between(-4, 6), r1);
-    r1.dropBackRange(0);
+    r1.shrinkBack(0);
     EXPECT_EQ(IndexRange::between(-4, 6), r1);
-    r1.dropBackRange(r1.length());
+    r1.shrinkBack(r1.length());
     EXPECT_TRUE(r1.empty());
 
     auto r2 = IndexRange::between(9, -4);
-    r2.dropBackRange(3);
+    r2.shrinkBack(3);
     EXPECT_EQ(IndexRange::between(9, -1), r2);
-    r2.dropBackRange(0);
+    r2.shrinkBack(0);
     EXPECT_EQ(IndexRange::between(9, -1), r2);
-    r2.dropBackRange(r2.length());
+    r2.shrinkBack(r2.length());
     EXPECT_TRUE(r2.empty());
 }
 
-TEST_F(IndexRangeTest, cutBackRange) {
+TEST_F(IndexRangeTest, splitAndShrinkBack) {
     auto r1 = IndexRange::between(-4, 9);
-    EXPECT_EQ(IndexRange::between(6, 9), r1.cutBackRange(3));
+    EXPECT_EQ(IndexRange::between(6, 9), r1.splitAndShrinkBack(3));
     EXPECT_EQ(IndexRange::between(-4, 6), r1);
-    EXPECT_TRUE(r1.cutBackRange(0).empty());
+    EXPECT_TRUE(r1.splitAndShrinkBack(0).empty());
     EXPECT_EQ(IndexRange::between(-4, 6), r1);
-    EXPECT_EQ(IndexRange::between(-4, 6), r1.cutBackRange(r1.length()));
+    EXPECT_EQ(IndexRange::between(-4, 6), r1.splitAndShrinkBack(r1.length()));
     EXPECT_TRUE(r1.empty());
 
     auto r2 = IndexRange::between(9, -4);
-    EXPECT_EQ(IndexRange::between(-1, -4), r2.cutBackRange(3));
+    EXPECT_EQ(IndexRange::between(-1, -4), r2.splitAndShrinkBack(3));
     EXPECT_EQ(IndexRange::between(9, -1), r2);
-    EXPECT_TRUE(r2.cutBackRange(0).empty());
+    EXPECT_TRUE(r2.splitAndShrinkBack(0).empty());
     EXPECT_EQ(IndexRange::between(9, -1), r2);
-    EXPECT_EQ(IndexRange::between(9, -1), r2.cutBackRange(r2.length()));
+    EXPECT_EQ(IndexRange::between(9, -1), r2.splitAndShrinkBack(r2.length()));
     EXPECT_TRUE(r2.empty());
 }
 
diff --git a/src/util/indexrange.cpp b/src/util/indexrange.cpp
index becb92df7a..ff9f9d994c 100644
--- a/src/util/indexrange.cpp
+++ b/src/util/indexrange.cpp
@@ -6,25 +6,7 @@
 
 namespace mixxx {
 
-void IndexRange::growFrontRange(SINT frontLength) {
-    DEBUG_ASSERT(frontLength >= 0);
-    if (first <= second) {
-        first -= frontLength;
-    } else {
-        first += frontLength;
-    }
-}
-
-void IndexRange::growBackRange(SINT backLength) {
-    DEBUG_ASSERT(backLength >= 0);
-    if (first <= second) {
-        second += backLength;
-    } else {
-        second -= backLength;
-    }
-}
-
-IndexRange IndexRange::cutFrontRange(SINT frontLength) {
+IndexRange IndexRange::splitAndShrinkFront(SINT frontLength) {
     DEBUG_ASSERT(frontLength >= 0);
     DEBUG_ASSERT(frontLength <= length());
     if (start() <= end()) {
@@ -42,7 +24,7 @@ IndexRange IndexRange::cutFrontRange(SINT frontLength) {
     }
 }
 
-IndexRange IndexRange::cutBackRange(SINT backLength) {
+IndexRange IndexRange::splitAndShrinkBack(SINT backLength) {
     DEBUG_ASSERT(backLength >= 0);
     DEBUG_ASSERT(backLength <= length());
     if (start() <= end()) {
diff --git a/src/util/indexrange.h b/src/util/indexrange.h
index dc93481d77..34c056a9b3 100644
--- a/src/util/indexrange.h
+++ b/src/util/indexrange.h
@@ -88,24 +88,28 @@ class IndexRange final: private std::pair<SINT, SINT> {
         }
     }
 
-    void growFrontRange(SINT frontLength);
-
-    void growBackRange(SINT backLength);
-
-    // Splits this range into two adjacent parts by slicing off
-    // and returning a range of given length and same direction
-    // from the front side. The given front length must not exceed
-    // the length of this range.
-    IndexRange cutFrontRange(SINT frontLength);
+    // Grow the range by appending the given length at the front side.
+    void growFront(SINT frontLength) {
+        DEBUG_ASSERT(frontLength >= 0);
+        if (start() <= end()) {
+            first -= frontLength;
+        } else {
+            first += frontLength;
+        }
+    }
 
-    // Splits this range into two adjacent parts by slicing off
-    // and returning a range of given length and same direction
-    // from the back side. The given back length must not exceed
-    // the length of this range.
-    IndexRange cutBackRange(SINT backLength);
+    // Grow the range by appending the given length at the back side.
+    void growBack(SINT backLength) {
+        DEBUG_ASSERT(backLength >= 0);
+        if (start() <= end()) {
+            second += backLength;
+        } else {
+            second -= backLength;
+        }
+    }
 
-    // Same as cutFrontRange(), but omitting the return value.
-    void dropFrontRange(SINT frontLength) {
+    // Shrink the range by cutting off the given length at the front side.
+    void shrinkFront(SINT frontLength) {
         DEBUG_ASSERT(frontLength >= 0);
         DEBUG_ASSERT(frontLength <= length());
         if (start() <= end()) {
@@ -115,8 +119,8 @@ class IndexRange final: private std::pair<SINT, SINT> {
         }
     }
 
-    // Same as cutBackRange(), but omitting the return value.
-    void dropBackRange(SINT backLength) {
+    // Shrink the range by cutting off the given length at the back side.
+    void shrinkBack(SINT backLength) {
         DEBUG_ASSERT(backLength >= 0);
         DEBUG_ASSERT(backLength <= length());
         if (start() <= end()) {
@@ -126,6 +130,18 @@ class IndexRange final: private std::pair<SINT, SINT> {
         }
     }
 
+    // Splits this range into two adjacent parts by slicing off
+    // and returning a range of given length and same direction
+    // from the front side. The given front length must not exceed
+    // the length of this range.
+    IndexRange splitAndShrinkFront(SINT frontLength);
+
+    // Splits this range into two adjacent parts by slicing off
+    // and returning a range of given length and same direction
+    // from the back side. The given back length must not exceed
+    // the length of this range.
+    IndexRange splitAndShrinkBack(SINT backLength);
+
     friend
     bool operator==(IndexRange lhs, IndexRange rhs) {
         return (lhs.first == rhs.first) && (lhs.second == rhs.second);
diff --git a/src/util/readaheadsamplebuffer.cpp b/src/util/readaheadsamplebuffer.cpp
index a5f0dc6974..6132df888b 100644
--- a/src/util/readaheadsamplebuffer.cpp
+++ b/src/util/readaheadsamplebuffer.cpp
@@ -38,7 +38,7 @@ ReadAheadSampleBuffer::ReadAheadSampleBuffer(
         m_sampleBuffer.data(),
         that.m_sampleBuffer.data(that.m_readableRange.start()),
         that.readableLength());
-    m_readableRange.growBackRange(that.readableLength());
+    m_readableRange.growBack(that.readableLength());
     
     DEBUG_ASSERT_CLASS_INVARIANT_ReadAheadSampleBuffer;
 }
@@ -62,7 +62,7 @@ SampleBuffer::WritableSlice ReadAheadSampleBuffer::write(SINT writeLength) {
     const SINT tailLength = math_min(writeLength, writableLength());
     const SampleBuffer::WritableSlice tailSlice(
             m_sampleBuffer, m_readableRange.end(), tailLength);
-    m_readableRange.growBackRange(tailLength);
+    m_readableRange.growBack(tailLength);
 
     DEBUG_ASSERT_CLASS_INVARIANT_ReadAheadSampleBuffer;
     return tailSlice;
@@ -72,7 +72,7 @@ SampleBuffer::ReadableSlice ReadAheadSampleBuffer::readFifo(SINT readLength) {
     DEBUG_ASSERT_CLASS_INVARIANT_ReadAheadSampleBuffer;
 
     const SINT tailLength = math_min(readLength, readableLength());
-    m_readableRange.dropBackRange(tailLength);
+    m_readableRange.shrinkBack(tailLength);
     const SampleBuffer::ReadableSlice tailSlice(
             m_sampleBuffer, m_readableRange.end(), tailLength);
     adjustReadableRange();
@@ -87,7 +87,7 @@ SampleBuffer::ReadableSlice ReadAheadSampleBuffer::readLifo(SINT readLength) {
     const SINT headLength = math_min(readLength, readableLength());
     const SampleBuffer::ReadableSlice headSlice(
             m_sampleBuffer, m_readableRange.start(), headLength);
-    m_readableRange.dropFrontRange(headLength);
+    m_readableRange.shrinkFront(headLength);
     adjustReadableRange();
 
     DEBUG_ASSERT_CLASS_INVARIANT_ReadAheadSampleBuffer;