sort criterias and queryconditions list

app/src/androidTest/java/net/pokeranalytics/android/model/CriteriaTest.kt

@@ -0,0 +1,61 @@
+package net.pokeranalytics.android.model
+
+import net.pokeranalytics.android.components.BaseFilterInstrumentedUnitTest
+import net.pokeranalytics.android.components.RealmInstrumentedUnitTest
+import net.pokeranalytics.android.model.filter.QueryCondition
+import net.pokeranalytics.android.model.realm.Filter
+import net.pokeranalytics.android.model.realm.FilterCondition
+import net.pokeranalytics.android.model.realm.Session
+import net.pokeranalytics.android.ui.view.rowrepresentable.FilterSectionRow
+import org.junit.Assert
+import org.junit.Test
+
+import org.junit.Assert.*
+import java.util.*
+
+class CriteriaTest : BaseFilterInstrumentedUnitTest() {
+
+    @Test
+    fun getQueryConditions() {
+
+        val realm = this.mockRealm
+        realm.beginTransaction()
+        val cal = Calendar.getInstance()
+        cal.time = Date()
+        val s1 = Session.testInstance(100.0, false, cal.time)
+        cal.add(Calendar.YEAR, 1)
+        Session.testInstance(100.0, true, cal.time)
+        cal.add(Calendar.YEAR, -11)
+        val firstValue = cal.get(Calendar.YEAR)
+        Session.testInstance(100.0, true, cal.time)
+        cal.add(Calendar.YEAR, 7)
+        Session.testInstance(100.0, true, cal.time)
+        cal.add(Calendar.YEAR, -2)
+        Session.testInstance(100.0, true, cal.time)
+        cal.add(Calendar.YEAR, 10)
+        Session.testInstance(100.0, true, cal.time)
+
+        val lastValue = firstValue + 10
+
+        realm.commitTransaction()
+
+        val years = Criteria.Years.queryConditions as List<QueryCondition.AnyYear>
+        println("years = ${years.map { it.getDisplayName() }}")
+
+        assertEquals(11, years.size)
+        assertEquals(firstValue, years.first().listOfValues.first())
+        assertEquals(lastValue, years.last().listOfValues.first())
+    }
+
+    @Test
+    fun combined() {
+
+        val critierias = listOf(Criteria.MonthsOfYear, Criteria.DaysOfWeek)
+        val combined = critierias.combined()
+        combined.forEach {
+            it.forEach {qc->
+                println(qc.getDisplayName())
+            }
+        }
+    }
+}

app/src/main/java/net/pokeranalytics/android/model/Criteria.kt

@@ -3,6 +3,7 @@ package net.pokeranalytics.android.model
 import io.realm.Realm
 import io.realm.Sort
 import io.realm.kotlin.where
+import net.pokeranalytics.android.calculus.Stat
 import net.pokeranalytics.android.exceptions.PokerAnalyticsException
 import net.pokeranalytics.android.model.filter.QueryCondition
 import net.pokeranalytics.android.model.interfaces.NameManageable
@@ -10,10 +11,54 @@ import net.pokeranalytics.android.model.realm.*
 import java.util.*
 import kotlin.collections.ArrayList
 
+fun List<Criteria>.combined(): List<List<QueryCondition>> {
+    val comparatorList = ArrayList<List<QueryCondition>>()
+    this.forEach {
+        comparatorList.add(it.queryConditions)
+    }
+    return getCombinations(comparatorList)
+}
+
+fun <T> getCombinations(lists: List<List<T>>): List<List<T>> {
+    var combinations: LinkedHashSet<List<T>> = LinkedHashSet()
+    var newCombinations: LinkedHashSet<List<T>>
+
+    var index = 0
+
+    // extract each of the integers in the first list
+    // and add each to ints as a new list
+    if (lists.isNotEmpty()) {
+        for (i in lists[0]) {
+            val newList = ArrayList<T>()
+            newList.add(i)
+            combinations.add(newList)
+        }
+        index++
+    }
+    while (index < lists.size) {
+        val nextList = lists[index]
+        newCombinations = LinkedHashSet()
+        for (first in combinations) {
+            for (second in nextList) {
+                val newList = ArrayList<T>()
+                newList.addAll(first)
+                newList.add(second)
+                newCombinations.add(newList)
+            }
+        }
+        combinations = newCombinations
+
+        index++
+    }
+
+    return combinations.toList()
+}
+
+
 sealed class Criteria {
     abstract class RealmCriteria : Criteria() {
         inline fun <reified T: NameManageable> comparison(): List<QueryCondition> {
-            return compare < QueryCondition.QueryDataCondition<NameManageable >, T >()
+            return compare < QueryCondition.QueryDataCondition<NameManageable >, T >().sorted()
         }
     }
 
@@ -38,7 +83,7 @@ sealed class Criteria {
                 }
                 return compareList<T, S>(values = values)
             }
-            return listOf<T>()
+            return listOf<T>().sorted()
         }
     }
 
@@ -56,7 +101,7 @@ sealed class Criteria {
     object SessionTypes: SimpleCriteria(listOf(QueryCondition.IsCash, QueryCondition.IsTournament))
     object BankrollTypes: SimpleCriteria(listOf(QueryCondition.IsLive, QueryCondition.IsOnline))
     object DayPeriods: SimpleCriteria(listOf(QueryCondition.IsWeekDay, QueryCondition.IsWeekEnd))
-    object Years: Criteria()
+    object Years: ListCriteria()
     object Blinds: ListCriteria()
     object TournamentFees: ListCriteria()
 
@@ -87,7 +132,7 @@ sealed class Criteria {
                         }
                     }
                     realm.close()
-                    years
+                    years.sorted()
                 }
                 is Blinds -> comparison<QueryCondition.AnyBlind, String >()
                 else -> throw PokerAnalyticsException.QueryTypeUnhandled
@@ -117,47 +162,4 @@ sealed class Criteria {
             return objects
         }
     }
-
-    fun List<Criteria>.combined(): List<List<QueryCondition>> {
-        val comparatorList = ArrayList<List<QueryCondition>>()
-        this.forEach {
-            comparatorList.add(it.queryConditions)
-        }
-        return getCombinations(comparatorList)
-    }
-
-    private fun <T> getCombinations(lists: List<List<T>>): List<List<T>> {
-        var combinations: MutableSet<List<T>> = LinkedHashSet()
-        var newCombinations: MutableSet<List<T>>
-
-        var index = 0
-
-        // extract each of the integers in the first list
-        // and add each to ints as a new list
-        if (lists.isNotEmpty()) {
-            for (i in lists[0]) {
-                val newList = ArrayList<T>()
-                newList.add(i)
-                combinations.add(newList)
-            }
-            index++
-        }
-        while (index < lists.size) {
-            val nextList = lists[index]
-            newCombinations = LinkedHashSet()
-            for (first in combinations) {
-                for (second in nextList) {
-                    val newList = ArrayList<T>()
-                    newList.addAll(first)
-                    newList.add(second)
-                    newCombinations.add(newList)
-                }
-            }
-            combinations = newCombinations
-
-            index++
-        }
-
-        return combinations.toList()
-    }
 }

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

@@ -71,16 +71,23 @@ sealed class QueryCondition : FilterElementRow {
             }
             return null
         }
+    }
 
+    interface ListOfValues <T>: Comparable<ListOfValues<T>> where T:Comparable<T> {
+        var listOfValues: ArrayList<T>
 
+        override fun compareTo(other: ListOfValues<T>): Int {
+            return listOfValues.sorted().first().compareTo(other.listOfValues.sorted().first())
         }
 
-    interface ListOfValues <T> {
-        var listOfValues: ArrayList<T>
     }
 
-    interface SingleValue <T> {
+    interface SingleValue <T>: Comparable<SingleValue<T>> where T:Comparable<T> {
         var singleValue : T
+
+        override fun compareTo(other: SingleValue<T>): Int {
+            return singleValue.compareTo(other.singleValue)
+        }
     }
 
     interface ListOfDouble: ListOfValues<Double>
@@ -165,7 +172,7 @@ sealed class QueryCondition : FilterElementRow {
         override var singleValue: Int = 0
     }
 
-    abstract class ListOfValueQueryCondition < T: Any >  : QueryCondition(), ListOfValues<T> {
+    abstract class ListOfValueQueryCondition < T >  : QueryCondition(), ListOfValues<T> where T:Comparable<T> {
         override var listOfValues =  ArrayList<T>()
         abstract fun labelForValue(value:T): String