Merge pull request #129 from oliverClimbs/master

Reliability updates to getEntryIndex

Author: hannesa2

MPChartLib/src/main/java/com/github/mikephil/charting/data/DataSet.java

@@ -331,77 +331,92 @@ public int getEntryIndex(float xValue, float closestToY, Rounding rounding) {
         int closest = high;
 
         while (low < high) {
-            int m = (low + high) / 2;
-
-            final float d1 = mEntries.get(m).getX() - xValue,
-                    d2 = mEntries.get(m + 1).getX() - xValue,
-                    ad1 = Math.abs(d1), ad2 = Math.abs(d2);
-
-            if (ad2 < ad1) {
-                // [m + 1] is closer to xValue
-                // Search in an higher place
-                low = m + 1;
-            } else if (ad1 < ad2) {
-                // [m] is closer to xValue
-                // Search in a lower place
-                high = m;
-            } else {
-                // We have multiple sequential x-value with same distance
+            int m = low + (high - low) / 2;
+
+            Entry currentEntry = mEntries.get(m);
+
+            if (currentEntry != null) {
+                Entry nextEntry = mEntries.get(m + 1);
+
+                if (nextEntry != null) {
+                    final float d1 = currentEntry.getX() - xValue,
+                                d2 = nextEntry.getX() - xValue,
+                                ad1 = Math.abs(d1),
+                                ad2 = Math.abs(d2);
+
+                    if (ad2 < ad1) {
+                        // [m + 1] is closer to xValue
+                        // Search in an higher place
+                        low = m + 1;
+                    } else if (ad1 < ad2) {
+                        // [m] is closer to xValue
+                        // Search in a lower place
+                        high = m;
+                    } else {
+                        // We have multiple sequential x-value with same distance
+
+                        if (d1 >= 0.0) {
+                            // Search in a lower place
+                            high = m;
+                        } else if (d1 < 0.0) {
+                            // Search in an higher place
+                            low = m + 1;
+                        }
+                    }
 
-                if (d1 >= 0.0) {
-                    // Search in a lower place
-                    high = m;
-                } else if (d1 < 0.0) {
-                    // Search in an higher place
-                    low = m + 1;
+                    closest = high;
                 }
             }
-
-            closest = high;
         }
 
         if (closest != -1) {
-            float closestXValue = mEntries.get(closest).getX();
-            if (rounding == Rounding.UP) {
-                // If rounding up, and found x-value is lower than specified x, and we can go upper...
-                if (closestXValue < xValue && closest < mEntries.size() - 1) {
-                    ++closest;
-                }
-            } else if (rounding == Rounding.DOWN) {
-                // If rounding down, and found x-value is upper than specified x, and we can go lower...
-                if (closestXValue > xValue && closest > 0) {
-                    --closest;
+            Entry closestEntry = mEntries.get(closest);
+            if (closestEntry != null) {
+                float closestXValue = closestEntry.getX();
+                if (rounding == Rounding.UP) {
+                    // If rounding up, and found x-value is lower than specified x, and we can go upper...
+                    if (closestXValue < xValue && closest < mEntries.size() - 1) {
+                        ++closest;
+                    }
+                } else if (rounding == Rounding.DOWN) {
+                    // If rounding down, and found x-value is upper than specified x, and we can go lower...
+                    if (closestXValue > xValue && closest > 0) {
+                        --closest;
+                    }
                 }
-            }
 
-            // Search by closest to y-value
-            if (!Float.isNaN(closestToY)) {
-                while (closest > 0 && mEntries.get(closest - 1).getX() == closestXValue)
-                    closest -= 1;
+                // Search by closest to y-value
+                if (!Float.isNaN(closestToY)) {
+                    while (closest > 0 && mEntries.get(closest - 1).getX() == closestXValue)
+                        closest -= 1;
 
-                float closestYValue = mEntries.get(closest).getY();
-                int closestYIndex = closest;
+                    float closestYValue = closestEntry.getY();
+                    int closestYIndex = closest;
 
-                while (true) {
-                    closest += 1;
-                    if (closest >= mEntries.size())
-                        break;
+                    while (true) {
+                        closest += 1;
+                        if (closest >= mEntries.size())
+                            break;
 
-                    final Entry value = mEntries.get(closest);
+                        final Entry value = mEntries.get(closest);
 
-                    if (value.getX() != closestXValue)
-                        break;
+                        if (value == null) {
+                            continue;
+                        }
+
+                        if (value.getX() != closestXValue)
+                            break;
 
-                    if (Math.abs(value.getY() - closestToY) <= Math.abs(closestYValue - closestToY)) {
-                        closestYValue = closestToY;
-                        closestYIndex = closest;
+                        if (Math.abs(value.getY() - closestToY) <= Math.abs(closestYValue - closestToY)) {
+                            closestYValue = closestToY;
+                            closestYIndex = closest;
+                        }
                     }
-                }
 
-                closest = closestYIndex;
+                    closest = closestYIndex;
+                }
             }
         }
-
         return closest;
     }