Merge pull request #3 from gaze-network/feat/is-uint-funcs

Add IsUint64(), IsUint32(), IsUint16(), isUint8()

Author: gazenw

README.md

@@ -10,6 +10,7 @@ This project is a fork of [lukechampine/uint128](https://github.com/lukechampine
    - Add `AddOverflow`, `Add64Overflow`, `SubOverflow`, `Sub64Overflow`, `MulOverflow`, `Mul64Overflow` functions which returns additional boolean indicating whether the operation overflowed. The original functions now ignores overflow instead of panicking.
    - Change `FromBig` function behaviour to return errors instead of panicking.
 2. Add conversion functions `Uint64()`, `Uint32()`, `Uint16()`, `Uint8()` to convert `Uint128` to native types.
+3. Add functions `IsUint64()`, `IsUint32()`, `IsUint16()`, `IsUint8()` to check if `Uint128` can be converted to native types without overflow.
 
 `uint128` provides a high-performance `Uint128` type that supports standard arithmetic
 operations. Unlike `math/big`, operations on `Uint128` values always produce new values

uint128.go

@@ -52,6 +52,26 @@ func (u Uint128) Uint8() uint8 {
 	return uint8(u.Lo)
 }
 
+// Uint returns true if u can be safely represented as a uint64.
+func (u Uint128) IsUint64() bool {
+	return u.Hi == 0
+}
+
+// Uint returns true if u can be safely represented as a uint32.
+func (u Uint128) IsUint32() bool {
+	return u.Hi == 0 && u.Lo <= math.MaxUint32
+}
+
+// Uint returns true if u can be safely represented as a uint16.
+func (u Uint128) IsUint16() bool {
+	return u.Hi == 0 && u.Lo <= math.MaxUint16
+}
+
+// Uint returns true if u can be safely represented as a uint8.
+func (u Uint128) IsUint8() bool {
+	return u.Hi == 0 && u.Lo <= math.MaxUint8
+}
+
 // Equals returns true if u == v.
 //
 // Uint128 values can be compared directly with ==, but use of the Equals method

uint128_test.go

@@ -54,6 +54,18 @@ func TestUint128(t *testing.T) {
 		if x.Uint8() != uint8(x.Lo) {
 			t.Fatal("Uint8 is not the lowest 8 bits of Lo for", x)
 		}
+		if x.IsUint64() != (x.Hi == 0) {
+			t.Fatal("IsUint64 is not equivalent to Hi == 0 for", x)
+		}
+		if x.IsUint32() != (x.Hi == 0 && x.Lo <= math.MaxUint32) {
+			t.Fatal("IsUint32 is not equivalent to Hi == 0 && Lo <= math.MaxUint32 for", x)
+		}
+		if x.IsUint16() != (x.Hi == 0 && x.Lo <= math.MaxUint16) {
+			t.Fatal("IsUint16 is not equivalent to Hi == 0 && Lo <= math.MaxUint16 for", x)
+		}
+		if x.IsUint8() != (x.Hi == 0 && x.Lo <= math.MaxUint8) {
+			t.Fatal("IsUint8 is not equivalent to Hi == 0 && Lo <= math.MaxUint8 for", x)
+		}
 
 		b := make([]byte, 16)
 		x.PutBytes(b)