From badc61da415f6c50201f1d2830ab5a7a38fe68f1 Mon Sep 17 00:00:00 2001
From: Janne Koschinski <janne@kuschku.de>
Date: Fri, 20 Apr 2018 15:07:22 +0200
Subject: [PATCH] Further cleanup

---
 .../de/kuschku/libquassel/util/flag/Flag.kt   | 66 +++++++++----------
 .../kuschku/libquassel/util/flag/LongFlag.kt  | 59 ++++++++---------
 .../kuschku/libquassel/util/flag/ShortFlag.kt | 63 +++++++++---------
 3 files changed, 90 insertions(+), 98 deletions(-)

diff --git a/lib/src/main/java/de/kuschku/libquassel/util/flag/Flag.kt b/lib/src/main/java/de/kuschku/libquassel/util/flag/Flag.kt
index dd43df5d1..bf06c4a35 100644
--- a/lib/src/main/java/de/kuschku/libquassel/util/flag/Flag.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/util/flag/Flag.kt
@@ -47,19 +47,16 @@ data class Flags<E>(
 
   companion object {
     inline fun <reified T> of(int: Int): Flags<T>
-      where T : Flag<T>, T : Enum<T> = Flags(
-      int,
-      enumValues())
+      where T : Flag<T>, T : Enum<T> =
+      Flags(int, enumValues())
 
     inline fun <reified T> of(vararg flags: T): Flags<T>
       where T : Flag<T>, T : Enum<T> =
-      Flags(flags.map(Flag<T>::bit).distinct().sum(),
-            enumValues())
+      Flags(flags.map(Flag<T>::bit).distinct().sum(), enumValues())
 
     inline fun <reified T> of(flags: Iterable<T>): Flags<T>
       where T : Flag<T>, T : Enum<T> =
-      Flags(flags.map(Flag<T>::bit).distinct().sum(),
-            enumValues())
+      Flags(flags.map(Flag<T>::bit).distinct().sum(), enumValues())
   }
 
   interface Factory<E> where E : Flag<E>, E : Enum<E> {
@@ -72,59 +69,58 @@ data class Flags<E>(
 
 infix fun <T> Flags<T>.hasFlag(which: T): Boolean where T : Enum<T>, T : Flag<T> {
   // an Undefined flag is a special case.
-  if (value == 0 || (value > 0 && which.bit == 0)) return false
-
+  if (value == 0) return false
   return value and which.bit == which.bit
 }
 
 infix fun <T> Flags<T>.or(other: Int): Flags<T>
-  where T : kotlin.Enum<T>, T : Flag<T> = Flags(
-  value or other)
+  where T : kotlin.Enum<T>, T : Flag<T> =
+  Flags(value or other)
 
 infix fun <T> Flags<T>.or(other: Flag<T>): Flags<T>
-  where T : kotlin.Enum<T>, T : Flag<T> = Flags(
-  value or other.bit)
+  where T : kotlin.Enum<T>, T : Flag<T> =
+  Flags(value or other.bit)
 
 infix fun <T> Flags<T>.or(other: Flags<T>): Flags<T>
-  where T : kotlin.Enum<T>, T : Flag<T> = Flags(
-  value or other.value)
+  where T : kotlin.Enum<T>, T : Flag<T> =
+  Flags(value or other.value)
 
 infix fun <T> Flags<T>.and(other: Int): Flags<T>
-  where T : kotlin.Enum<T>, T : Flag<T> = Flags(
-  value and other)
+  where T : kotlin.Enum<T>, T : Flag<T> =
+  Flags(value and other)
 
 infix fun <T> Flags<T>.and(other: Flag<T>): Flags<T>
-  where T : kotlin.Enum<T>, T : Flag<T> = Flags(
-  value and other.bit)
+  where T : kotlin.Enum<T>, T : Flag<T> =
+  Flags(value and other.bit)
 
 infix fun <T> Flags<T>.and(other: Flags<T>): Flags<T>
-  where T : kotlin.Enum<T>, T : Flag<T> = Flags(
-  value and other.value)
+  where T : kotlin.Enum<T>, T : Flag<T> =
+  Flags(value and other.value)
 
 infix operator fun <T> Flags<T>.plus(other: Int): Flags<T>
-  where T : Enum<T>, T : Flag<T> = Flags(
-  value or other)
+  where T : Enum<T>, T : Flag<T> =
+  Flags(value or other)
 
 infix operator fun <T> Flags<T>.plus(other: Flag<T>): Flags<T>
-  where T : Enum<T>, T : Flag<T> = Flags(
-  value or other.bit)
+  where T : Enum<T>, T : Flag<T> =
+  Flags(value or other.bit)
 
 infix operator fun <T> Flags<T>.plus(other: Flags<T>): Flags<T>
-  where T : Enum<T>, T : Flag<T> = Flags(
-  value or other.value)
+  where T : Enum<T>, T : Flag<T> =
+  Flags(value or other.value)
 
 infix operator fun <T> Flags<T>.minus(other: Int): Flags<T>
-  where T : Enum<T>, T : Flag<T> = Flags(
-  value and other.inv())
+  where T : Enum<T>, T : Flag<T> =
+  Flags(value and other.inv())
 
 infix operator fun <T> Flags<T>.minus(other: Flag<T>): Flags<T>
-  where T : Enum<T>, T : Flag<T> = Flags(
-  value and other.bit.inv())
+  where T : Enum<T>, T : Flag<T> =
+  Flags(value and other.bit.inv())
 
 infix operator fun <T> Flags<T>.minus(other: Flags<T>): Flags<T>
-  where T : Enum<T>, T : Flag<T> = Flags(
-  value and other.value.inv())
+  where T : Enum<T>, T : Flag<T> =
+  Flags(value and other.value.inv())
 
 infix fun <T> Flags<T>.unset(which: T): Flags<T>
-  where T : Enum<T>, T : Flag<T> = Flags(
-  value xor which.bit)
+  where T : Enum<T>, T : Flag<T> =
+  Flags(value xor which.bit)
diff --git a/lib/src/main/java/de/kuschku/libquassel/util/flag/LongFlag.kt b/lib/src/main/java/de/kuschku/libquassel/util/flag/LongFlag.kt
index fb5279105..eee94e117 100644
--- a/lib/src/main/java/de/kuschku/libquassel/util/flag/LongFlag.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/util/flag/LongFlag.kt
@@ -47,8 +47,8 @@ data class LongFlags<E>(
 
   companion object {
     inline fun <reified T> of(int: Long): LongFlags<T>
-      where T : LongFlag<T>, T : Enum<T> = LongFlags(
-      int,
+      where T : LongFlag<T>, T : Enum<T> =
+      LongFlags(int,
       enumValues())
 
     inline fun <reified T> of(vararg flags: LongFlag<T>): LongFlags<T>
@@ -71,59 +71,58 @@ data class LongFlags<E>(
 
 infix fun <T> LongFlags<T>.hasFlag(which: T): Boolean where T : Enum<T>, T : LongFlag<T> {
   // an Undefined flag is a special case.
-  if (value == 0.toLong() || (value > 0 && which.bit == 0.toLong())) return false
-
+  if (value == 0L) return false
   return value and which.bit == which.bit
 }
 
 infix fun <T> LongFlags<T>.or(other: Long): LongFlags<T>
-  where T : kotlin.Enum<T>, T : LongFlag<T> = LongFlags(
-  value or other)
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value or other)
 
 infix fun <T> LongFlags<T>.or(other: LongFlag<T>): LongFlags<T>
-  where T : kotlin.Enum<T>, T : LongFlag<T> = LongFlags(
-  value or other.bit)
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value or other.bit)
 
 infix fun <T> LongFlags<T>.or(other: LongFlags<T>): LongFlags<T>
-  where T : kotlin.Enum<T>, T : LongFlag<T> = LongFlags(
-  value or other.value)
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value or other.value)
 
 infix fun <T> LongFlags<T>.and(other: Long): LongFlags<T>
-  where T : kotlin.Enum<T>, T : LongFlag<T> = LongFlags(
-  value and other)
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value and other)
 
 infix fun <T> LongFlags<T>.and(other: LongFlag<T>): LongFlags<T>
-  where T : kotlin.Enum<T>, T : LongFlag<T> = LongFlags(
-  value and other.bit)
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value and other.bit)
 
 infix fun <T> LongFlags<T>.and(other: LongFlags<T>): LongFlags<T>
-  where T : kotlin.Enum<T>, T : LongFlag<T> = LongFlags(
-  value and other.value)
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value and other.value)
 
 infix operator fun <T> LongFlags<T>.plus(other: Long): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> = LongFlags(
-  value or other)
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value or other)
 
 infix operator fun <T> LongFlags<T>.plus(other: LongFlag<T>): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> = LongFlags(
-  value or other.bit)
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value or other.bit)
 
 infix operator fun <T> LongFlags<T>.plus(other: LongFlags<T>): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> = LongFlags(
-  value or other.value)
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value or other.value)
 
 infix operator fun <T> LongFlags<T>.minus(other: Long): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> = LongFlags(
-  value and other.inv())
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value and other.inv())
 
 infix operator fun <T> LongFlags<T>.minus(other: LongFlag<T>): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> = LongFlags(
-  value and other.bit.inv())
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value and other.bit.inv())
 
 infix operator fun <T> LongFlags<T>.minus(other: LongFlags<T>): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> = LongFlags(
-  value and other.value.inv())
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value and other.value.inv())
 
 infix fun <T> LongFlags<T>.unset(which: T): LongFlags<T>
-  where T : Enum<T>, T : LongFlag<T> = LongFlags(
-  value xor which.bit)
+  where T : Enum<T>, T : LongFlag<T> =
+  LongFlags(value xor which.bit)
diff --git a/lib/src/main/java/de/kuschku/libquassel/util/flag/ShortFlag.kt b/lib/src/main/java/de/kuschku/libquassel/util/flag/ShortFlag.kt
index b7e4baed3..c6d07c35d 100644
--- a/lib/src/main/java/de/kuschku/libquassel/util/flag/ShortFlag.kt
+++ b/lib/src/main/java/de/kuschku/libquassel/util/flag/ShortFlag.kt
@@ -52,19 +52,16 @@ data class ShortFlags<E>(
 
   companion object {
     inline fun <reified T> of(int: Short): ShortFlags<T>
-      where T : ShortFlag<T>, T : Enum<T> = ShortFlags(
-      int,
-      enumValues())
+      where T : ShortFlag<T>, T : Enum<T> =
+      ShortFlags(int, enumValues())
 
     inline fun <reified T> of(vararg flags: ShortFlag<T>): ShortFlags<T>
       where T : ShortFlag<T>, T : Enum<T> =
-      ShortFlags(flags.map(ShortFlag<T>::bit).distinct().sum().toShort(),
-                 enumValues())
+      ShortFlags(flags.map(ShortFlag<T>::bit).distinct().sum().toShort(), enumValues())
 
     inline fun <reified T> of(flags: Iterable<T>): ShortFlags<T>
       where T : ShortFlag<T>, T : Enum<T> =
-      ShortFlags(flags.map(ShortFlag<T>::bit).distinct().sum().toShort(),
-                 enumValues())
+      ShortFlags(flags.map(ShortFlag<T>::bit).distinct().sum().toShort(), enumValues())
   }
 
   interface Factory<E> where E : ShortFlag<E>, E : Enum<E> {
@@ -82,53 +79,53 @@ infix fun <T> ShortFlags<T>.hasFlag(which: T): Boolean where T : Enum<T>, T : Sh
 }
 
 infix fun <T> ShortFlags<T>.or(other: Short): ShortFlags<T>
-  where T : kotlin.Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value or other)
+  where T : kotlin.Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value or other)
 
 infix fun <T> ShortFlags<T>.or(other: ShortFlag<T>): ShortFlags<T>
-  where T : kotlin.Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value or other.bit)
+  where T : kotlin.Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value or other.bit)
 
 infix fun <T> ShortFlags<T>.or(other: ShortFlags<T>): ShortFlags<T>
-  where T : kotlin.Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value or other.value)
+  where T : kotlin.Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value or other.value)
 
 infix fun <T> ShortFlags<T>.and(other: Short): ShortFlags<T>
-  where T : kotlin.Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value and other)
+  where T : kotlin.Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value and other)
 
 infix fun <T> ShortFlags<T>.and(other: ShortFlag<T>): ShortFlags<T>
-  where T : kotlin.Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value and other.bit)
+  where T : kotlin.Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value and other.bit)
 
 infix fun <T> ShortFlags<T>.and(other: ShortFlags<T>): ShortFlags<T>
-  where T : kotlin.Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value and other.value)
+  where T : kotlin.Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value and other.value)
 
 infix operator fun <T> ShortFlags<T>.plus(other: Short): ShortFlags<T>
-  where T : Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value or other)
+  where T : Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value or other)
 
 infix operator fun <T> ShortFlags<T>.plus(other: ShortFlag<T>): ShortFlags<T>
-  where T : Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value or other.bit)
+  where T : Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value or other.bit)
 
 infix operator fun <T> ShortFlags<T>.plus(other: ShortFlags<T>): ShortFlags<T>
-  where T : Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value or other.value)
+  where T : Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value or other.value)
 
 infix operator fun <T> ShortFlags<T>.minus(other: Short): ShortFlags<T>
-  where T : Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value and other.inv())
+  where T : Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value and other.inv())
 
 infix operator fun <T> ShortFlags<T>.minus(other: ShortFlag<T>): ShortFlags<T>
-  where T : Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value and other.bit.inv())
+  where T : Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value and other.bit.inv())
 
 infix operator fun <T> ShortFlags<T>.minus(other: ShortFlags<T>): ShortFlags<T>
-  where T : Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value and other.value.inv())
+  where T : Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value and other.value.inv())
 
 infix fun <T> ShortFlags<T>.unset(which: T): ShortFlags<T>
-  where T : Enum<T>, T : ShortFlag<T> = ShortFlags(
-  value xor which.bit)
+  where T : Enum<T>, T : ShortFlag<T> =
+  ShortFlags(value xor which.bit)
-- 
GitLab