seeking java 1.7 compatibility

Author: elect86

src/main/kotlin/unsigned/Long.kt

@@ -1,4 +1,5 @@
 import unsigned.*
+import unsigned.java_1_7.toUnsignedString
 import java.math.BigInteger
 
 /**

src/main/kotlin/unsigned/Ubyte.kt

@@ -1,5 +1,8 @@
 package unsigned
 
+import unsigned.java_1_7.compareUnsigned
+import unsigned.java_1_7.divideUnsigned
+import unsigned.java_1_7.remainderUnsigned
 import java.math.BigInteger
 import kotlin.experimental.and
 import kotlin.experimental.inv
@@ -21,7 +24,7 @@ data class Ubyte(var v: Byte = 0) : Number() {
     }
 
     constructor(number: Number) : this(number.toByte())
-    @JvmOverloads constructor(string: String, base: Int = 10) : this(Integer.parseUnsignedInt(string.filter { it != '_' && it != '\'' }, base).toShort())
+    @JvmOverloads constructor(string: String, base: Int = 10) : this(Integer.parseUnsignedInt(string.filter { it != '_' && it != '\'' }, base).toByte())
 
     override fun toByte() = v
     override fun toShort() = v.toUInt().toShort()
@@ -57,11 +60,11 @@ data class Ubyte(var v: Byte = 0) : Number() {
 
     infix operator fun div(b: Ubyte) = Ubyte(toInt() / b.toInt())
     infix operator fun div(b: Byte) = Ubyte(toInt() / b.toUInt())
-    infix operator fun div(b: Int) = Ubyte(Integer.divideUnsigned(toInt(), b))
+    infix operator fun div(b: Int) = Ubyte(toInt().divideUnsigned(b))
 
     infix operator fun rem(b: Ubyte) = Ubyte(toInt() % b.toInt())
     infix operator fun rem(b: Byte) = Ubyte(toInt() % b.toUInt())
-    infix operator fun rem(b: Int) = Ubyte(Integer.remainderUnsigned(toInt(), b))
+    infix operator fun rem(b: Int) = Ubyte(toInt().remainderUnsigned(b))
 
     // TODO add counterparts with res
 
@@ -87,7 +90,7 @@ data class Ubyte(var v: Byte = 0) : Number() {
 
     fun inv() = Ubyte(v.inv())
 
-    operator fun compareTo(b: Ubyte) = Integer.compareUnsigned(toInt(), b.toInt())
-    operator fun compareTo(b: Byte) = Integer.compareUnsigned(toInt(), b.toUInt())
-    operator fun compareTo(b: Int) = Integer.compareUnsigned(toInt(), b)
+    operator fun compareTo(b: Ubyte) = toInt().compareUnsigned(b.toInt())
+    operator fun compareTo(b: Byte) = toInt().compareUnsigned(b.toUInt())
+    operator fun compareTo(b: Int) = toInt().compareUnsigned(b)
 }

src/main/kotlin/unsigned/java_1_7/int.kt

@@ -0,0 +1,39 @@
+package unsigned.java_1_7
+
+import java.math.BigInteger
+
+
+// In lieu of tricky code, for now just use long arithmetic.
+fun Int.divideUnsigned(divisor: Int) = (toUnsignedLong() / divisor.toUnsignedLong()).toInt()
+
+fun Int.toUnsignedLong() = toLong() and 0xffffffffL
+
+// In lieu of tricky code, for now just use long arithmetic.
+fun Int.remainderUnsigned(divisor: Int) = (toUnsignedLong() % divisor.toUnsignedLong()).toInt()
+
+fun Int.compareUnsigned(b: Int) = compare(this + Int.MIN_VALUE, b + Int.MIN_VALUE)
+
+fun compare(x: Int, y: Int) = if (x < y) -1 else if (x == y) 0 else 1
+
+@Throws(NumberFormatException::class)
+fun String.parseUnsignedInt(radix: Int): Int {
+
+    val len = length
+    if (len > 0) {
+        val firstChar = this[0]
+        if (firstChar == '-')
+            throw NumberFormatException(String.format("Illegal leading minus sign " + "on unsigned string %s.", this))
+        else {
+            if (len <= 5 || // Integer.MAX_VALUE in Character.MAX_RADIX is 6 digits
+                    radix == 10 && len <= 9) // Integer.MAX_VALUE in base 10 is 10 digits
+                return this.toInt(radix)
+            else {
+                val ell = this.toLong(radix)
+                if (ell and BigInteger("0xffff_ffff_0000_0000").toLong() == 0L)
+                    return ell.toInt()
+                else
+                    throw NumberFormatException(String.format("String value %s exceeds " + "range of unsigned int.", this))
+            }
+        }
+    } else throw NumberFormatException("For input string: $this")
+}

src/main/kotlin/unsigned/java_1_7.kt renamed to src/main/kotlin/unsigned/java_1_7/long.kt

@@ -1,13 +1,12 @@
-package unsigned
+package unsigned.java_1_7
 
 import java.math.BigInteger
 
 
-fun Long.toUnsignedString(radix: Int = 10): String =
-    if (this >= 0)
-        toString(radix)
-    else
-        when (radix) {
+fun Long.toUnsignedString(radix: Int = 10): String {
+    return when {
+        this >= 0 -> toString(radix)
+        else -> when (radix) {
             2 -> toBinaryString()
 
             4 -> toUnsignedString0(2)
@@ -34,6 +33,8 @@ fun Long.toUnsignedString(radix: Int = 10): String =
 
             else -> toUnsignedBigInteger().toString(radix)
         }
+    }
+}
 
 fun Long.toString(radix: Int): String {
     var i = this