BaseEntry generic

to be able to use it as Float or Double

Author: hannesa2

chartLib/src/main/kotlin/info/appdev/charting/data/BaseEntry.kt

@@ -2,10 +2,10 @@ package info.appdev.charting.data
 
 import android.graphics.drawable.Drawable
 
-abstract class BaseEntry {
+abstract class BaseEntry<T> where T : Number, T : Comparable<T> {
 
-    protected var yBase: Float = 0f
-    open var y: Float
+    protected lateinit var yBase: T
+    open var y: T
         get() = yBase
         set(value) {
             yBase = value
@@ -17,19 +17,19 @@ abstract class BaseEntry {
 
     constructor()
 
-    constructor(y: Float) {
+    constructor(y: T) {
         this.yBase = y
     }
 
-    constructor(y: Float, data: Any?) : this(y) {
+    constructor(y: T, data: Any?) : this(y) {
         this.data = data
     }
 
-    constructor(y: Float, icon: Drawable?) : this(y) {
+    constructor(y: T, icon: Drawable?) : this(y) {
         this.icon = icon
     }
 
-    constructor(y: Float, icon: Drawable?, data: Any?) : this(y) {
+    constructor(y: T, icon: Drawable?, data: Any?) : this(y) {
         this.icon = icon
         this.data = data
     }

chartLib/src/main/kotlin/info/appdev/charting/data/Entry.kt

@@ -13,7 +13,7 @@ import kotlin.math.abs
  * Class representing one entry in the chart. Might contain multiple values.
  * Might only contain a single value depending on the used constructor.
  */
-open class Entry : BaseEntry, Parcelable, Serializable {
+open class Entry : BaseEntry<Float>, Parcelable, Serializable {
 
     private var _x: Float = 0f
     open var x: Float

chartLib/src/main/kotlin/info/appdev/charting/data/EntryDouble.kt

@@ -1,3 +1,151 @@
 package info.appdev.charting.data
 
-class EntryDouble(val xDouble: Double, y: Float) : Entry(xDouble.toFloat(), y)
+import android.graphics.drawable.Drawable
+import android.os.Build
+import android.os.Parcel
+import android.os.ParcelFormatException
+import android.os.Parcelable
+import info.appdev.charting.utils.Utils
+import java.io.Serializable
+import kotlin.math.abs
+
+open class EntryDouble : BaseEntry<Double>, Parcelable, Serializable {
+
+    private var _x: Double = 0.0
+    open var x: Double
+        get() = _x
+        set(value) {
+            _x = value
+        }
+
+    constructor()
+
+    /**
+     * A Entry represents one single entry in the chart.
+     *
+     * @param x the x value
+     * @param y the y value (the actual value of the entry)
+     */
+    constructor(x: Double, y: Double) : super(y) {
+        this._x = x
+    }
+
+    /**
+     * A Entry represents one single entry in the chart.
+     *
+     * @param x    the x value
+     * @param y    the y value (the actual value of the entry)
+     * @param data Spot for additional data this Entry represents.
+     */
+    constructor(x: Double, y: Double, data: Any?) : super(y, data) {
+        this._x = x
+    }
+
+    /**
+     * A Entry represents one single entry in the chart.
+     *
+     * @param x the x value
+     * @param y the y value (the actual value of the entry)
+     * @param icon icon image
+     */
+    constructor(x: Double, y: Double, icon: Drawable?) : super(y, icon) {
+        this._x = x
+    }
+
+    /**
+     * A Entry represents one single entry in the chart.
+     *
+     * @param x the x value
+     * @param y the y value (the actual value of the entry)
+     * @param icon icon image
+     * @param data Spot for additional data this Entry represents.
+     */
+    constructor(x: Double, y: Double, icon: Drawable?, data: Any?) : super(y, icon, data) {
+        this._x = x
+    }
+
+    /**
+     * returns an exact copy of the entry
+     */
+    open fun copy(): EntryDouble {
+        val e = EntryDouble(x, y, data)
+        return e
+    }
+
+    /**
+     * Compares value, xIndex and data of the entries. Returns true if entries
+     * are equal in those points, false if not. Does not check by hash-code like
+     * it's done by the "equals" method.
+     */
+    fun equalTo(e: EntryDouble?): Boolean {
+        if (e == null)
+            return false
+
+        if (e.data !== this.data)
+            return false
+
+        if (abs((e.x - this.x)) > Utils.DOUBLE_EPSILON)
+            return false
+
+        if (abs((e.y - this.y)) > Utils.DOUBLE_EPSILON)
+            return false
+
+        return true
+    }
+
+    /**
+     * returns a string representation of the entry containing x-index and value
+     */
+    override fun toString(): String {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            "${this.javaClass.typeName.substringAfterLast(".")} x=$x y=$y"
+        } else {
+            "EntryDouble x=$x y=$y"
+        }
+    }
+
+    override fun describeContents(): Int {
+        return 0
+    }
+
+    override fun writeToParcel(dest: Parcel, flags: Int) {
+        dest.writeDouble(this.x)
+        dest.writeDouble(this.y)
+        if (data != null) {
+            if (data is Parcelable) {
+                dest.writeInt(1)
+                dest.writeParcelable(data as Parcelable?, flags)
+            } else {
+                throw ParcelFormatException("Cannot parcel an EntryDouble with non-parcelable data")
+            }
+        } else {
+            dest.writeInt(0)
+        }
+    }
+
+    protected constructor(`in`: Parcel) {
+        this._x = `in`.readDouble()
+        this.yBase = `in`.readDouble()
+        if (`in`.readInt() == 1) {
+            this.data = if (Build.VERSION.SDK_INT >= 33) {
+                `in`.readParcelable(Any::class.java.classLoader, Any::class.java)
+            } else {
+                @Suppress("DEPRECATION")
+                `in`.readParcelable(Any::class.java.classLoader)
+            }
+        }
+    }
+
+    companion object {
+        @JvmField
+        val CREATOR: Parcelable.Creator<EntryDouble> = object : Parcelable.Creator<EntryDouble> {
+            override fun createFromParcel(source: Parcel): EntryDouble {
+                return EntryDouble(source)
+            }
+
+            override fun newArray(size: Int): Array<EntryDouble?> {
+                return arrayOfNulls(size)
+            }
+        }
+    }
+}

chartLib/src/main/kotlin/info/appdev/charting/utils/Utils.kt

@@ -7,6 +7,7 @@ import android.view.VelocityTracker
 import android.view.ViewConfiguration
 import info.appdev.charting.formatter.DefaultValueFormatter
 import info.appdev.charting.formatter.IValueFormatter
+import java.lang.Float.intBitsToFloat
 import kotlin.math.abs
 import kotlin.math.cos
 import kotlin.math.sin
@@ -23,6 +24,7 @@ object Utils {
     const val FDEG2RAD: Float = (Math.PI.toFloat() / 180f)
 
     val FLOAT_EPSILON: Float = java.lang.Float.intBitsToFloat(1)
+    val DOUBLE_EPSILON: Double = java.lang.Double.longBitsToDouble(1L)
 
     /**
      * initialize method, called inside the Chart.init() method.