Fixes important bugs

app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/BlindFilterInstrumentedTest.kt

@@ -47,9 +47,9 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
             listOfValues = arrayListOf(s1.blinds!!)
         }
 
-        blind.filterSectionRow = FilterSectionRow.Blind
+//        blind.filterSectionRow = FilterSectionRow.Blind
 
-        val filterElement = FilterCondition(filterElementRows = arrayListOf(blind))
+        val filterElement = FilterCondition(arrayListOf(blind), FilterSectionRow.Blind)
         filter.updateValueBy(filterElement)
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
@@ -97,10 +97,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
             listOfValues = arrayListOf(s2.blinds!!)
         }
 
-        blind1.filterSectionRow = FilterSectionRow.Blind
-        blind2.filterSectionRow = FilterSectionRow.Blind
-
-        val filterElements = FilterCondition(filterElementRows = arrayListOf(blind1, blind2))
+        val filterElements = FilterCondition(arrayListOf(blind1, blind2), FilterSectionRow.Blind)
         filter.updateValueBy(filterElements)
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
@@ -146,9 +143,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
             listOfValues = arrayListOf(s3.blinds!!)
         }
 
-        blind.filterSectionRow = FilterSectionRow.Blind
-
-        val filterElement = FilterCondition(filterElementRows = arrayListOf(blind))
+        val filterElement = FilterCondition(arrayListOf(blind), FilterSectionRow.Blind)
         filter.updateValueBy(filterElement)
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -196,10 +191,7 @@ class BlindFilterInstrumentedTest : BaseFilterInstrumentedUnitTest() {
             listOfValues = arrayListOf(s2.blinds!!)
         }
 
-        blind1.filterSectionRow = FilterSectionRow.Blind
-        blind2.filterSectionRow = FilterSectionRow.Blind
-
-        val filterElement = FilterCondition(filterElementRows = arrayListOf(blind1, blind2))
+        val filterElement = FilterCondition(arrayListOf(blind1, blind2), FilterSectionRow.Blind)
         filter.updateValueBy(filterElement)
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))

app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/DateFilterInstrumentedUnitTest.kt

@@ -35,8 +35,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         cal.time = s1.startDate
 
         val filterElementRow = QueryCondition.AnyDayOfWeek().apply { listOfValues = arrayListOf(cal.get(Calendar.DAY_OF_WEEK)) }
-        filterElementRow.filterSectionRow = FilterSectionRow.DynamicDate
-        val filterElement = FilterCondition(arrayListOf(filterElementRow))
+        val filterElement = FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.DynamicDate)
         filter.updateValueBy(filterElement)
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
@@ -64,8 +63,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         cal.time = s1.startDate
         val filterElementRow = QueryCondition.AnyMonthOfYear().apply { listOfValues = arrayListOf(cal.get(Calendar.MONTH)) }
 
-        filterElementRow.filterSectionRow = FilterSectionRow.DynamicDate
-        val filterElement = FilterCondition(arrayListOf(filterElementRow))
+        val filterElement = FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.DynamicDate)
         filter.updateValueBy(filterElement)
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
@@ -92,8 +90,7 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val filter = QueryCondition.AnyYear()
         cal.time = s1.startDate
         val filterElementRow = QueryCondition.AnyYear().apply { listOfValues = arrayListOf(cal.get(Calendar.YEAR)) }
-        filterElementRow.filterSectionRow = FilterSectionRow.DynamicDate
-        val filterElement = FilterCondition(arrayListOf(filterElementRow))
+        val filterElement = FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.DynamicDate)
         filter.updateValueBy(filterElement)
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
@@ -384,10 +381,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val s2 = Session.testInstance(100.0, true, cal.time, 1)
         realm.commitTransaction()
 
-        val filter = QueryCondition.StartedFromDate()
-        val filterElementRow = QueryCondition.StartedFromDate().apply { singleValue = s2.startDate!!}
-        filterElementRow.filterSectionRow = FilterSectionRow.FixedDate
-        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
+        val filter = QueryCondition.StartedFromDate(Date())
+        val filterElementRow = QueryCondition.StartedFromDate(Date()).apply { singleValue = s2.startDate!!}
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.FixedDate))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -412,10 +408,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         realm.commitTransaction()
 
-        val filter = QueryCondition.StartedToDate()
-        val filterElementRow = QueryCondition.StartedToDate().apply { singleValue = s1.startDate!! }
-        filterElementRow.filterSectionRow = FilterSectionRow.FixedDate
-        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
+        val filter = QueryCondition.StartedToDate(Date())
+        val filterElementRow = QueryCondition.StartedToDate(Date()).apply { singleValue = s1.startDate!! }
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.FixedDate))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -441,10 +436,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         realm.commitTransaction()
 
-        val filter = QueryCondition.EndedFromDate()
-        val filterElementRow = QueryCondition.EndedFromDate().apply { singleValue = s2.endDate() }
-        filterElementRow.filterSectionRow = FilterSectionRow.FixedDate
-        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
+        val filter = QueryCondition.EndedFromDate(Date())
+        val filterElementRow = QueryCondition.EndedFromDate(Date()).apply { singleValue = s2.endDate() }
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.FixedDate))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -470,10 +464,9 @@ class DateFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
 
-        val filter = QueryCondition.EndedToDate()
-        val filterElementRow = QueryCondition.EndedToDate().apply { singleValue = s1.endDate() }
-        filterElementRow.filterSectionRow = FilterSectionRow.FixedDate
-        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
+        val filter = QueryCondition.EndedToDate(Date())
+        val filterElementRow = QueryCondition.EndedToDate(Date()).apply { singleValue = s1.endDate() }
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.FixedDate))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 

app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/RealmFilterInstrumentedUnitTest.kt

@@ -5,6 +5,7 @@ import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest
 import net.pokeranalytics.android.model.filter.QueryCondition
 import net.pokeranalytics.android.model.realm.Filter
 import net.pokeranalytics.android.model.realm.Session
+import net.pokeranalytics.android.ui.view.rowrepresentable.BaseFilterItemRow
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterCategoryRow
 import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
 import org.junit.Assert
@@ -24,8 +25,9 @@ class RealmFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         filter.name = "testSaveLoadCashFilter"
 
         val filterElement = QueryCondition.IsCash
-//        filterElement.filterSectionRow = FilterSectionRow.CashOrTournament
-        filter.createOrUpdateFilterConditions(arrayListOf(filterElement), FilterSectionRow.CashOrTournament)
+        val filterItemRow = BaseFilterItemRow(filterElement, FilterSectionRow.CashOrTournament)
+
+        filter.createOrUpdateFilterConditions(arrayListOf(filterItemRow))
 
         val useCount = filter.countBy(FilterCategoryRow.GENERAL)
         Assert.assertEquals(1, useCount)

app/src/androidTest/java/net/pokeranalytics/android/unitTests/filter/SessionFilterInstrumentedUnitTest.kt

@@ -110,8 +110,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val filter = QueryCondition.AnyBankroll()
         val filterElementRow = QueryCondition.AnyBankroll().apply { setObject(b1) }
-        filterElementRow.filterSectionRow = FilterSectionRow.Bankroll
-        filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.Bankroll))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -141,11 +140,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val filter = QueryCondition.AnyBankroll()
         val filterElementRow = QueryCondition.AnyBankroll().apply { setObject(b1) }
-        filterElementRow.filterSectionRow = FilterSectionRow.Bankroll
-
         val filterElementRow2 = QueryCondition.AnyBankroll().apply { setObject(b2) }
-        filterElementRow2.filterSectionRow = FilterSectionRow.Bankroll
-        filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
+
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow, filterElementRow2), FilterSectionRow.Bankroll))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -169,7 +166,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
         val anyGame = QueryCondition.AnyGame(g2)
-        val fc = FilterCondition(filterElementRows = arrayListOf(anyGame))
+        val fc = FilterCondition(arrayListOf(anyGame), FilterSectionRow.Game)
         val sessions = Filter.queryOn<Session>(realm, Query(fc.queryCondition))
 
         Assert.assertEquals(1, sessions.size)
@@ -197,10 +194,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         realm.commitTransaction()
 
         val filterElementRow = QueryCondition.AnyGame().apply { setObject(g2) }
-        filterElementRow.filterSectionRow = FilterSectionRow.Game
         val filterElementRow2 = QueryCondition.AnyGame().apply { setObject(g3) }
-        filterElementRow2.filterSectionRow = FilterSectionRow.Game
-        val filterCondition = FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2))
+
+        val filterCondition = FilterCondition(arrayListOf(filterElementRow, filterElementRow2), FilterSectionRow.Game)
+
         val queryCondition = filterCondition.queryCondition
         val sessions = Filter.queryOn<Session>(realm, Query(queryCondition))
 
@@ -225,8 +222,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val filter = QueryCondition.AnyLocation()
         val filterElementRow = QueryCondition.AnyLocation().apply { setObject(l1) }
-        filterElementRow.filterSectionRow = FilterSectionRow.Location
-        filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.Location))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -257,11 +253,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val filter = QueryCondition.AnyLocation()
 
         val filterElementRow = QueryCondition.AnyLocation().apply { setObject(l1) }
-        filterElementRow.filterSectionRow = FilterSectionRow.Location
         val filterElementRow2 = QueryCondition.AnyLocation().apply { setObject(l3) }
-        filterElementRow2.filterSectionRow = FilterSectionRow.Location
 
-        filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow, filterElementRow2), FilterSectionRow.Location))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -287,8 +281,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
         val filter = QueryCondition.AnyTournamentName()
 
         val filterElementRow = QueryCondition.AnyTournamentName().apply { setObject(t1) }
-        filterElementRow.filterSectionRow = FilterSectionRow.TournamentName
-        filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.TournamentName))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -318,10 +311,8 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val filter = QueryCondition.AnyTournamentName()
         val filterElementRow = QueryCondition.AnyTournamentName().apply { setObject(t1) }
-        filterElementRow.filterSectionRow = FilterSectionRow.TournamentName
         val filterElementRow2 = QueryCondition.AnyTournamentName().apply { setObject(t2) }
-        filterElementRow.filterSectionRow = FilterSectionRow.TournamentName
-        filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow, filterElementRow2), FilterSectionRow.TournamentName))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -354,12 +345,10 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val filter = QueryCondition.AllTournamentFeature()
         val filterElementRow = QueryCondition.AllTournamentFeature().apply { setObject(t1) }
-        filterElementRow.filterSectionRow = FilterSectionRow.TournamentFeature
         val filterElementRow2 = QueryCondition.AllTournamentFeature().apply { setObject(t2) }
-        filterElementRow2.filterSectionRow = FilterSectionRow.TournamentFeature
         val filterElementRow3 = QueryCondition.AllTournamentFeature().apply { setObject(t4) }
-        filterElementRow3.filterSectionRow = FilterSectionRow.TournamentFeature
-        filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3)))
+
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow, filterElementRow2, filterElementRow3), FilterSectionRow.TournamentFeature))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -389,14 +378,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val filter = QueryCondition.AnyTournamentFeature()
         val filterElementRow = QueryCondition.AnyTournamentFeature().apply { setObject(t1) }
-        filterElementRow.filterSectionRow = FilterSectionRow.TournamentFeature
         val filterElementRow2 = QueryCondition.AnyTournamentFeature().apply { setObject(t2) }
-        filterElementRow2.filterSectionRow = FilterSectionRow.TournamentFeature
         val filterElementRow3 = QueryCondition.AnyTournamentFeature().apply { setObject(t3) }
-        filterElementRow3.filterSectionRow = FilterSectionRow.TournamentFeature
         val filterElementRow4 = QueryCondition.AnyTournamentFeature().apply { setObject(t4) }
-        filterElementRow4.filterSectionRow = FilterSectionRow.TournamentFeature
-        filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2, filterElementRow3, filterElementRow4)))
+
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow, filterElementRow2, filterElementRow3, filterElementRow4), FilterSectionRow.TournamentFeature))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -423,8 +409,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val filter = QueryCondition.AnyTournamentFeature()
         val filterElementRow = QueryCondition.AnyTournamentFeature().apply { setObject(t2) }
-        filterElementRow.filterSectionRow = FilterSectionRow.TournamentFeature
-        filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow)))
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.TournamentFeature))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -448,10 +433,9 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val filter = QueryCondition.AnyTableSize()
         val filterElementRow = QueryCondition.AnyTableSize().apply { listOfValues = arrayListOf(2) }
-        filterElementRow.filterSectionRow = FilterSectionRow.TableSize
         val filterElementRow2 = QueryCondition.AnyTableSize().apply { listOfValues = arrayListOf(4) }
-        filterElementRow.filterSectionRow = FilterSectionRow.TableSize
-        filter.updateValueBy(FilterCondition(filterElementRows = arrayListOf(filterElementRow, filterElementRow2)))
+
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow, filterElementRow2), FilterSectionRow.TableSize))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -475,8 +459,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val filter = QueryCondition.NetAmountWon()
         val filterElementRow = QueryCondition.more<QueryCondition.NetAmountWon>().apply { listOfValues = arrayListOf(204.0) }
-        filterElementRow.filterSectionRow = FilterSectionRow.Value
-        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.Value))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filterElementRow))
 
@@ -500,8 +483,7 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val filter = QueryCondition.NetAmountWon()
         val filterElementRow = QueryCondition.less<QueryCondition.NetAmountWon>().apply { listOfValues = arrayListOf(540.0) }
-        filterElementRow.filterSectionRow = FilterSectionRow.Value
-        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
+        filter.updateValueBy(FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.Value))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filter))
 
@@ -525,13 +507,11 @@ class SessionFilterInstrumentedUnitTest : BaseFilterInstrumentedUnitTest() {
 
         val filterMore = QueryCondition.NetAmountWon()
         val filterElementRow = QueryCondition.more<QueryCondition.NetAmountWon>().apply { listOfValues = arrayListOf(199.0) }
-        filterElementRow.filterSectionRow = FilterSectionRow.Value
-        filterMore.updateValueBy(FilterCondition(arrayListOf(filterElementRow)))
+        filterMore.updateValueBy(FilterCondition(arrayListOf(filterElementRow), FilterSectionRow.Value))
 
         val filterLess = QueryCondition.NetAmountWon()
         val filterElementRow2 = QueryCondition.less<QueryCondition.NetAmountWon>().apply { listOfValues = arrayListOf(400.0) }
-        filterElementRow2.filterSectionRow = FilterSectionRow.Value
-        filterLess.updateValueBy(FilterCondition(arrayListOf(filterElementRow2)))
+        filterLess.updateValueBy(FilterCondition(arrayListOf(filterElementRow2), FilterSectionRow.Value))
 
         val sessions = Filter.queryOn<Session>(realm, Query(filterMore, filterLess))
 

app/src/main/java/net/pokeranalytics/android/model/filter/QueryCondition.kt

@@ -25,6 +25,7 @@ import net.pokeranalytics.android.util.extensions.*
 import java.text.DateFormatSymbols
 import java.text.NumberFormat
 import java.util.*
+import kotlin.reflect.KClass
 
 /**
  * Enum describing the way a query should be handled
@@ -34,12 +35,32 @@ import java.util.*
 sealed class QueryCondition : RowRepresentable {
 
 	companion object {
+
+		fun <T: Any> newInstance(kClass: KClass<T>): T {
+			return try {
+				kClass.objectInstance ?: kClass.java.newInstance()
+			} catch (e: Exception) {
+				// some object instance can fail due to: java.lang.Class has no zero argument constructor
+				// We should have just one constructor with a single parameter
+
+				val primaryConstructor = kClass.java.declaredConstructors.first()
+				val paramClass = primaryConstructor.parameterTypes.first()
+				val param = when (paramClass) {
+					Int::class.java -> 0
+					Double::class.java -> 0.0
+					else -> paramClass.newInstance()
+				}
+				val constructor = kClass.java.getDeclaredConstructor(paramClass)
+				constructor.newInstance(param)
+			}
+		}
+
 		inline fun <reified T : QueryCondition> more(): T {
-			return T::class.java.newInstance().apply { this.operator = Operator.MORE }
+			return newInstance(T::class).apply { this.operator = Operator.MORE }
 		}
 
 		inline fun <reified T : QueryCondition> less(): T {
-			return T::class.java.newInstance().apply { this.operator = Operator.LESS }
+			return newInstance(T::class).apply { this.operator = Operator.LESS }
 		}
 
 		inline fun <reified T : QueryCondition> moreOrLess(): ArrayList<T> {
@@ -48,16 +69,7 @@ sealed class QueryCondition : RowRepresentable {
 
 		fun <T : QueryCondition> valueOf(name: String): T {
 			val kClass = Class.forName("${QueryCondition::class.qualifiedName}$$name").kotlin
-			val instance = try {
-				kClass.objectInstance ?: kClass.java.newInstance()
-			} catch (e: Exception) {
-				// some object instance can fail due to: java.lang.Class has no zero argument constructor
-				// We should have just one constructor with a single parameter
-				val primaryConstructor = kClass.java.declaredConstructors.first()
-				val param = primaryConstructor.parameterTypes.first()
-				primaryConstructor.newInstance(param.newInstance())
-			}
-			return instance as T
+			return newInstance(kClass) as T
 		}
 
 		inline fun <reified T : Identifiable> getInstance(): QueryCondition {
@@ -633,7 +645,7 @@ sealed class QueryCondition : RowRepresentable {
 		}
 	}
 
-	class CustomFieldQuery() : QueryDataCondition<CustomField>() {
+	class CustomFieldQuery : QueryDataCondition<CustomField>() {
 		override var entity: Class<CustomField> = CustomField::class.java
 	}
 
@@ -656,7 +668,9 @@ sealed class QueryCondition : RowRepresentable {
 			val completeLabel = when (listOfValues.size) {
 				0 -> return NULL_TEXT
 				1, 2 -> {
-					return name + prefix + listOfValues.map { labelForValue(it, context) }.joinToString(", ")
+					return name + prefix + listOfValues.joinToString(", ") {
+						labelForValue(it, context)
+					}
 				}
 				else -> "${listOfValues.size} $prefix $name"
 			}

app/src/main/java/net/pokeranalytics/android/model/realm/FilterCondition.kt

@@ -49,7 +49,7 @@ open class FilterCondition() : RealmObject() {
     var stringValue: String? = null
     var operator: Int? = null
 
-    inline fun <reified T:Any > getValues(): ArrayList < T > {
+    inline fun <reified T> getValues(): ArrayList <T> {
         return when (T::class) {
             Int::class -> ArrayList<T>().apply { intValues?.map { add(it as T) } }
             Double::class -> ArrayList<T>().apply { doubleValues?.map { add(it as T) } }
@@ -58,7 +58,17 @@ open class FilterCondition() : RealmObject() {
         }
     }
 
-    inline fun <reified T:Any > getValue(): T {
+    fun <T> getv(clazz: Class<T>) : T {
+        return when (clazz) {
+            Int::class -> intValue ?: 0
+            Double::class -> doubleValue?: 0.0
+            Date::class -> dateValue ?: Date()
+            String::class -> stringValue ?: ""
+            else -> throw PokerAnalyticsException.QueryValueMapUnexpectedValue
+        } as T
+    }
+
+    inline fun <reified T> getValue(): T {
         return when (T::class) {
             Int::class -> intValue ?: 0
             Double::class -> doubleValue?: 0.0

app/src/main/java/net/pokeranalytics/android/ui/modules/calendar/CalendarDetailsActivity.kt

@@ -3,7 +3,7 @@ package net.pokeranalytics.android.ui.modules.calendar
 import android.content.Context
 import android.content.Intent
 import android.os.Bundle
-import androidx.lifecycle.ViewModelProviders
+import androidx.lifecycle.ViewModelProvider
 import net.pokeranalytics.android.R
 import net.pokeranalytics.android.calculus.ComputedResults
 import net.pokeranalytics.android.model.filter.QueryCondition
@@ -13,7 +13,7 @@ import net.pokeranalytics.android.ui.activity.components.BaseActivity
 class CalendarDetailsActivity : BaseActivity() {
 
 	private val model: CalendarDetailsViewModel by lazy {
-		ViewModelProviders.of(this).get(CalendarDetailsViewModel::class.java)
+		ViewModelProvider(this).get(CalendarDetailsViewModel::class.java)
 	}
 
 	companion object {

app/src/main/java/net/pokeranalytics/android/ui/modules/filter/FilterDetailsFragment.kt

@@ -208,8 +208,8 @@ open class FilterDetailsFragment : RealmFragment(), RowRepresentableDelegate {
 			}
 			is IntFilterItemRow -> {
 				when (value) {
-					is Int -> {
-						row.value = value
+					is String -> {
+						row.value = value.toInt()
 					}
 					is ArrayList<*> -> {
 						val hours: Int? = try {

app/src/main/java/net/pokeranalytics/android/ui/modules/filter/FilterDetailsViewModel.kt

@@ -82,8 +82,8 @@ class FilterDetailsViewModel(categoryRow: FilterCategoryRow, var filter: Filter)
 	private fun defineSelectedItems() {
 		this.rows.filterIsInstance<FilterItemRow>().forEach { item ->
 
-			val condition = item.queryCondition
-			if (condition != null && this.filter.contains(condition)) {
+			val condition = item.rawCondition
+			if (this.filter.contains(condition)) {
 
 				// Load items with appropriate value
 				this.filter.filterConditions.firstOrNull {

app/src/main/java/net/pokeranalytics/android/ui/view/rowrepresentable/FilterElementRow.kt

@@ -13,41 +13,11 @@ import java.util.*
 
 interface FilterItemRow : RowRepresentable {
 
+    val rawCondition: QueryCondition
     val queryCondition: QueryCondition?
     var filterSectionRow: FilterSectionRow
 
-    override fun editingDescriptors(map: Map<String, Any?>): ArrayList<RowRepresentableEditDescriptor>? {
-        return when (this.queryCondition) {
-            is QueryCondition.Duration -> {
-                val hours: String? by map
-                val minutes: String? by map
-                arrayListOf(
-                    RowRepresentableEditDescriptor(hours, R.string.hour, inputType = InputType.TYPE_CLASS_NUMBER),
-                    RowRepresentableEditDescriptor(minutes, R.string.minute, inputType = InputType.TYPE_CLASS_NUMBER)
-                )
-            }
-            is QueryCondition.ListOfValues<*> -> {
-                val valueAsString: String? by map
-                val hint = when (this.queryCondition?.operator) {
-                    QueryCondition.Operator.MORE, QueryCondition.Operator.LESS -> {
-                        when (this.queryCondition) {
-                            is QueryCondition.CustomFieldNumberQuery -> R.string.value
-                            is QueryCondition.CustomFieldAmountQuery -> R.string.amount
-                            else -> this.filterSectionRow.resId
-                        }
-                    }
-                    else -> this.resId
-                }
-
-                arrayListOf(
-                    RowRepresentableEditDescriptor(valueAsString, hint, inputType = InputType.TYPE_CLASS_NUMBER)
-                )
-            }
-            else -> super.editingDescriptors(map)
-        }
-    }
-
-    fun updateValue(it: FilterCondition) { }
+    fun updateValue(fc: FilterCondition) { }
 
     val sectionToExclude: List<FilterSectionRow>?
         get() {
@@ -73,8 +43,7 @@ interface FilterValueHolder {
 
 open class BaseFilterItemRow(queryCondition: QueryCondition, override var filterSectionRow: FilterSectionRow) : FilterItemRow {
 
-    var rawCondition: QueryCondition = queryCondition
-        private set
+    override val rawCondition: QueryCondition = queryCondition
 
     override val queryCondition: QueryCondition?
         get() { return rawCondition }
@@ -94,7 +63,36 @@ open class BaseFilterItemRow(queryCondition: QueryCondition, override var filter
     override val bottomSheetType: BottomSheetType
         get() { return this.rawCondition.bottomSheetType }
 
+    override fun editingDescriptors(map: Map<String, Any?>): ArrayList<RowRepresentableEditDescriptor>? {
+        return when (this.rawCondition) {
+            is QueryCondition.Duration -> {
+                val hours: String? by map
+                val minutes: String? by map
+                arrayListOf(
+                    RowRepresentableEditDescriptor(hours, R.string.hour, inputType = InputType.TYPE_CLASS_NUMBER),
+                    RowRepresentableEditDescriptor(minutes, R.string.minute, inputType = InputType.TYPE_CLASS_NUMBER)
+                )
+            }
+            is QueryCondition.ListOfValues<*> -> {
+                val valueAsString: String? by map
+                val hint = when (this.queryCondition?.operator) {
+                    QueryCondition.Operator.MORE, QueryCondition.Operator.LESS -> {
+                        when (this.queryCondition) {
+                            is QueryCondition.CustomFieldNumberQuery -> R.string.value
+                            is QueryCondition.CustomFieldAmountQuery -> R.string.amount
+                            else -> this.filterSectionRow.resId
+                        }
+                    }
+                    else -> this.resId
+                }
 
+                arrayListOf(
+                    RowRepresentableEditDescriptor(valueAsString, hint, inputType = InputType.TYPE_CLASS_NUMBER)
+                )
+            }
+            else -> super.editingDescriptors(map)
+        }
+    }
 
 }
 
@@ -127,16 +125,14 @@ abstract class ValueFilterItemRow<T: Comparable<T>>(queryCondition: QueryConditi
         }
 
     override fun updateValue(fc: FilterCondition) {
-
-        // TODO
-
-//        this.value = fc.queryCondition.
-
+        val queryCondition = fc.queryCondition as QueryCondition.SingleValue<T>
+        this.value = queryCondition.singleValue
     }
 
 }
 
-abstract class ValueListFilterItemRow<T: Comparable<T>>(queryCondition: QueryCondition.ListOfValues<T>, filterSectionRow: FilterSectionRow): BaseFilterItemRow(queryCondition, filterSectionRow), FilterValueHolder {
+abstract class ValueListFilterItemRow<T: Comparable<T>>(queryCondition: QueryCondition.ListOfValues<T>, filterSectionRow: FilterSectionRow)
+    : BaseFilterItemRow(queryCondition, filterSectionRow), FilterValueHolder {
 
     private var listCondition: QueryCondition.ListOfValues<T> = queryCondition
 
@@ -157,7 +153,6 @@ abstract class ValueListFilterItemRow<T: Comparable<T>>(queryCondition: QueryCon
             }
         }
 
-
     override fun valueFormatted(context: Context): CharSequence? {
         this.list.firstOrNull()?.let {
             return this.listCondition.labelForValue(it, context)
@@ -175,11 +170,8 @@ abstract class ValueListFilterItemRow<T: Comparable<T>>(queryCondition: QueryCon
 //    }
 
     override fun updateValue(fc: FilterCondition) {
-
-        // TODO
-
-//        this.value = fc.queryCondition.
-
+        val queryCondition = fc.queryCondition as QueryCondition.ListOfValues<T>
+        this.list = queryCondition.listOfValues
     }
 }
 

app/src/test/java/net/pokeranalytics/android/InstantiationTest.kt

@@ -0,0 +1,27 @@
+package net.pokeranalytics.android
+
+import org.junit.Assert
+import org.junit.Test
+
+class IntHolder(var value: Int)
+class StringHolder(var value: String)
+
+class InstantiationTest : RealmUnitTest() {
+
+	@Test
+	fun testIntInstance() {
+
+		Assert.assertEquals(0, 0)
+
+		val c = IntHolder::class.java
+		val constructor = c.declaredConstructors.first()
+		val type = constructor.parameterTypes.first()
+		when (type) {
+			Int::class.java -> {
+				// good
+			}
+			else -> Assert.fail()
+		}
+	}
+
+}