Apply scalafmt

Command:
sbt scalafmtAll

1 files changed, 44 insertions, 22 deletions

diff --git a/src/main/scala/chisel3/util/experimental/decode/TruthTable.scala b/src/main/scala/chisel3/util/experimental/decode/TruthTable.scala
index 322466f9..e742fd66 100644
--- a/src/main/scala/chisel3/util/experimental/decode/TruthTable.scala
+++ b/src/main/scala/chisel3/util/experimental/decode/TruthTable.scala
@@ -13,10 +13,11 @@ sealed class TruthTable private (val table: Seq[(BitPat, BitPat)], val default:
     def writeRow(map: (BitPat, BitPat)): String =
       s"${map._1.rawString}->${map._2.rawString}"
 
-    (table.map(writeRow) ++ Seq(s"${" "*(inputWidth + 2)}${default.rawString}")).mkString("\n")
+    (table.map(writeRow) ++ Seq(s"${" " * (inputWidth + 2)}${default.rawString}")).mkString("\n")
   }
 
-  def copy(table: Seq[(BitPat, BitPat)] = this.table, default: BitPat = this.default, sort: Boolean = this.sort) = TruthTable(table, default, sort)
+  def copy(table: Seq[(BitPat, BitPat)] = this.table, default: BitPat = this.default, sort: Boolean = this.sort) =
+    TruthTable(table, default, sort)
 
   override def equals(y: Any): Boolean = {
     y match {
@@ -27,27 +28,36 @@ sealed class TruthTable private (val table: Seq[(BitPat, BitPat)], val default:
 }
 
 object TruthTable {
+
   /** Convert a table and default output into a [[TruthTable]]. */
   def apply(table: Iterable[(BitPat, BitPat)], default: BitPat, sort: Boolean = true): TruthTable = {
     require(table.map(_._1.getWidth).toSet.size == 1, "input width not equal.")
     require(table.map(_._2.getWidth).toSet.size == 1, "output width not equal.")
     val outputWidth = table.map(_._2.getWidth).head
-    val mergedTable = table.groupBy(_._1.toString).map { case (key, values) =>
-      // merge same input inputs.
-      values.head._1 -> BitPat(s"b${
-        Seq.tabulate(outputWidth) { i =>
-          val outputSet = values.map(_._2)
-            .map(_.rawString)
-            .map(_ (i))
-            .toSet
-            .filterNot(_ == '?')
-          require(outputSet.size != 2, s"TruthTable conflict in :\n${values.map { case (i, o) => s"${i.rawString}->${o.rawString}" }.mkString("\n")}")
-          outputSet.headOption.getOrElse('?')
-        }.mkString
-      }")
-    }.toSeq
+    val mergedTable = table
+      .groupBy(_._1.toString)
+      .map {
+        case (key, values) =>
+          // merge same input inputs.
+          values.head._1 -> BitPat(s"b${Seq
+            .tabulate(outputWidth) { i =>
+              val outputSet = values
+                .map(_._2)
+                .map(_.rawString)
+                .map(_(i))
+                .toSet
+                .filterNot(_ == '?')
+              require(
+                outputSet.size != 2,
+                s"TruthTable conflict in :\n${values.map { case (i, o) => s"${i.rawString}->${o.rawString}" }.mkString("\n")}"
+              )
+              outputSet.headOption.getOrElse('?')
+            }
+            .mkString}")
+      }
+      .toSeq
     import BitPat.bitPatOrder
-    new TruthTable(if(sort) mergedTable.sorted else mergedTable, default, sort)
+    new TruthTable(if (sort) mergedTable.sorted else mergedTable, default, sort)
   }
 
   /** Parse TruthTable from its string representation. */
@@ -77,10 +87,17 @@ object TruthTable {
       BitPat(s"b${bitPat.rawString.zipWithIndex.filter(b => indexes.contains(b._2)).map(_._1).mkString}")
 
     def tableFilter(indexes: Seq[Int]): Option[(TruthTable, Seq[Int])] = {
-      if(indexes.nonEmpty) Some((TruthTable(
-        table.table.map { case (in, out) => in -> bpFilter(out, indexes) },
-        bpFilter(table.default, indexes)
-      ), indexes)) else None
+      if (indexes.nonEmpty)
+        Some(
+          (
+            TruthTable(
+              table.table.map { case (in, out) => in -> bpFilter(out, indexes) },
+              bpFilter(table.default, indexes)
+            ),
+            indexes
+          )
+        )
+      else None
     }
 
     def index(bitPat: BitPat, bpType: Char): Seq[Int] =
@@ -99,7 +116,12 @@ object TruthTable {
     tables: Seq[(TruthTable, Seq[Int])]
   ): TruthTable = {
     def reIndex(bitPat: BitPat, table: TruthTable, indexes: Seq[Int]): Seq[(Char, Int)] =
-      table.table.map(a => a._1.toString -> a._2).collectFirst{ case (k, v) if k == bitPat.toString => v}.getOrElse(BitPat.dontCare(indexes.size)).rawString.zip(indexes)
+      table.table
+        .map(a => a._1.toString -> a._2)
+        .collectFirst { case (k, v) if k == bitPat.toString => v }
+        .getOrElse(BitPat.dontCare(indexes.size))
+        .rawString
+        .zip(indexes)
     def bitPat(indexedChar: Seq[(Char, Int)]) = BitPat(s"b${indexedChar
       .sortBy(_._2)
       .map(_._1)