Calculator now wraps object in a Report, Report -> ReportSetup + file renaming

app/src/main/java/net/pokeranalytics/android/calculus/Calculator.kt

@@ -60,7 +60,7 @@ class Calculator {
 
 	companion object {
 
-		fun computeStatsWithFilters(realm: Realm, filters: List<Filter>, options: Options): List<ComputedResults> {
+		fun computeStatsWithFilters(realm: Realm, filters: List<Filter>, options: Options): Report {
 
 			var computableGroups: MutableList<ComputableGroup> = mutableListOf()
 			filters.forEach { filter ->
@@ -75,9 +75,9 @@ class Calculator {
 		/**
 		 * Computes all stats for list of Session sessionGroup
 		 */
-		fun computeGroups(realm: Realm, groups: List<ComputableGroup>, options: Options): List<ComputedResults> {
+		fun computeGroups(realm: Realm, groups: List<ComputableGroup>, options: Options): Report {
 
-			val computedResults = mutableListOf<ComputedResults>()
+			val report = Report()
 			groups.forEach { group ->
 				val s = Date()
 
@@ -96,7 +96,7 @@ class Calculator {
 				}
 
 				results.finalize(options) // later treatment, such as evolution numericValues sorting
-				computedResults.add(results)
+				report.addResults(results)
 
 				val e = Date()
 				val duration = (e.time - s.time) / 1000.0
@@ -104,7 +104,7 @@ class Calculator {
 
 			}
 
-			return computedResults
+			return report
 		}
 
 		/**

app/src/main/java/net/pokeranalytics/android/calculus/Report.kt

@@ -10,6 +10,30 @@ import net.pokeranalytics.android.model.realm.ComputableResult
 import net.pokeranalytics.android.model.realm.Filter
 import net.pokeranalytics.android.model.realm.SessionSet
 
+class Report() {
+
+	private var _results: MutableList<ComputedResults> = mutableListOf()
+
+	val results: List<ComputedResults> = this._results
+
+//	private var groups: MutableList<ComputableGroup> = mutableListOf()
+//
+//	var options: Calculator.Options = options
+//
+//	fun addGroup(group: ComputableGroup) {
+//		this.groups.add(group)
+//	}
+//
+//	fun addGroups(groups: Collection<ComputableGroup>) {
+//		this.groups.addAll(groups)
+//	}
+
+	fun addResults(result: ComputedResults) {
+		this._results.add(result)
+	}
+
+}
+
 /**
  * A sessionGroup of computable items identified by a name
  */

app/src/main/java/net/pokeranalytics/android/model/migrations/PokerAnalyticsMigration.kt

@@ -36,6 +36,7 @@ class PokerAnalyticsMigration : RealmMigration {
 		if (currentVersion == 1) {
 			Timber.d("*** Running migration ${currentVersion + 1}")
 
+			schema.rename("Report", "ReportSetup")
 			schema.rename("FilterElement", "FilterCondition")
 			schema.get("Filter")?.let {
 				it.renameField("filterElements", "filterConditions")

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

@@ -11,7 +11,7 @@ enum class ReportDisplay {
     MAP
 }
 
-open class Report : RealmObject() {
+open class ReportSetup : RealmObject() {
 
     @PrimaryKey
     var id = UUID.randomUUID().toString()

app/src/main/java/net/pokeranalytics/android/ui/fragment/StatsFragment.kt

@@ -37,7 +37,7 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
 	private var stringTournament = ""
 
     private lateinit var statsAdapter: RowRepresentableAdapter
-	private var computedResults : List<ComputedResults>? = null
+	private var report : Report? = null
 
     companion object {
 
@@ -137,31 +137,31 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
 
 	    GlobalScope.launch(coroutineContext) {
 
-		    var results = listOf<ComputedResults>()
+		    var r = Report()
 		    val test = GlobalScope.async {
 			    val s = Date()
 			    Timber.d(">>> start...")
 
 			    val realm = Realm.getDefaultInstance()
-			    results = createSessionGroupsAndStartCompute(realm)
+			    r = createSessionGroupsAndStartCompute(realm)
-			    computedResults = results
+			    report = r
 			    realm.close()
 
 			    val e = Date()
 			    val duration = (e.time - s.time) / 1000.0
-			    Timber.d(">>> ended in ${duration} seconds")
+			    Timber.d(">>> ended in $duration seconds")
 
 		    }
 		    test.await()
 
 		    if (!isDetached) {
-			    showResults(results)
+			    showResults(r)
 		    }
 	    }
 
     }
 
-	private fun createSessionGroupsAndStartCompute(realm: Realm) : List<ComputedResults> {
+	private fun createSessionGroupsAndStartCompute(realm: Realm) : Report {
 
         val allStats: List<Stat> = listOf(Stat.NETRESULT, Stat.HOURLY_RATE, Stat.AVERAGE, Stat.NUMBER_OF_SETS, Stat.AVERAGE_DURATION, Stat.DURATION)
         val allSessionGroup = ComputableGroup(stringAll, listOf(), allStats)
@@ -176,16 +176,16 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
 
     }
 
-    private fun showResults(results: List<ComputedResults>) {
+    private fun showResults(report: Report) {
-        this.rowRepresentables = this.convertResultsIntoRepresentables(results)
+        this.rowRepresentables = this.convertReportIntoRepresentables(report)
 		statsAdapter.notifyDataSetChanged()
     }
 
-    private fun convertResultsIntoRepresentables(results: List<ComputedResults>) : ArrayList<RowRepresentable> {
+    private fun convertReportIntoRepresentables(report: Report) : ArrayList<RowRepresentable> {
 
         val rows: ArrayList<RowRepresentable> = ArrayList()
 
-        results.forEach { result ->
+        report.results.forEach { result ->
             rows.add(CustomizableRowRepresentable(title = result.group.name))
             result.group.stats?.forEach { stat ->
                 rows.add(StatRepresentable(stat, result.computedStat(stat), result.group.name))
@@ -202,7 +202,7 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
 		if (row is StatRepresentable) {
 
 			// filter groups
-			val groupResults = this.computedResults?.filter {
+			val groupResults = this.report?.results?.filter {
 				it.group.name == row.groupName
 			}
 
@@ -217,7 +217,7 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
 
 		GlobalScope.launch(coroutineContext) {
 
-			var results = listOf<ComputedResults>()
+			var report = Report()
 			val test = GlobalScope.async {
 				val s = Date()
 				Timber.d(">>> start...")
@@ -225,18 +225,18 @@ class StatsFragment : SessionObserverFragment(), StaticRowRepresentableDataSourc
 				val realm = Realm.getDefaultInstance()
 				val options = Calculator.Options()
 				options.evolutionValues = Calculator.Options.EvolutionValues.STANDARD
-				results = Calculator.computeGroups(realm, listOf(computableGroup), options)
+				report = Calculator.computeGroups(realm, listOf(computableGroup), options)
 				realm.close()
 
 				val e = Date()
 				val duration = (e.time - s.time) / 1000.0
-				Timber.d(">>> ended in ${duration} seconds")
+				Timber.d(">>> ended in $duration seconds")
 
 			}
 			test.await()
 
 			if (!isDetached) {
-				results.firstOrNull()?.defaultStatEntries(stat)?.let { entries ->
+				report.results.firstOrNull()?.defaultStatEntries(stat)?.let { entries ->
 					GraphActivity.newInstance(requireContext(), stat, entries)
 				}
 			}