Make YAML renderer include metadata

julianmendez · Jan 26, 2019 · e46778e · e46778e
1 parent abe5957
commit e46778e
Showing 1 changed file with 79 additions and 6 deletions.
diff --git a/tabulas-ext/src/main/scala/de/tudresden/inf/lat/tabulas/ext/renderer/YamlRenderer.scala b/tabulas-ext/src/main/scala/de/tudresden/inf/lat/tabulas/ext/renderer/YamlRenderer.scala
@@ -4,9 +4,12 @@ package de.tudresden.inf.lat.tabulas.ext.renderer
 import java.io.{OutputStreamWriter, Writer}
 import java.util.Objects
 
-import de.tudresden.inf.lat.tabulas.datatype.{CompositeTypeValue, ParameterizedListValue, PrimitiveTypeValue, Record, StringType, StringValue, URIType, URIValue}
+import de.tudresden.inf.lat.tabulas.datatype._
+import de.tudresden.inf.lat.tabulas.parser.ParserConstant
 import de.tudresden.inf.lat.tabulas.renderer.{Renderer, UncheckedWriter, UncheckedWriterImpl}
-import de.tudresden.inf.lat.tabulas.table.{Table, TableMap}
+import de.tudresden.inf.lat.tabulas.table.{PrefixMap, RecordImpl, Table, TableMap}
+
+import scala.collection.mutable
 
 /** Renderer that creates a YAML file.
   */
@@ -36,9 +39,12 @@ class YamlRenderer(output: Writer) extends Renderer {
   final val EscapedTab = "\\t"
   final val Slash = "/"
 
-  //  def addQuotes(str: String): String = {
-  //    QuotationMark + escapeString(str) + QuotationMark
-  //  }
+  final val MetadataTokens = Seq(
+    ParserConstant.TypeSelectionToken,
+    ParserConstant.TypeDefinitionToken,
+    ParserConstant.PrefixMapToken,
+    ParserConstant.SortingOrderDeclarationToken
+  )
 
   def escapeString(str: String): String = {
     val result = str.flatMap(ch => {
@@ -124,6 +130,73 @@ class YamlRenderer(output: Writer) extends Renderer {
     })
   }
 
+  def singleValueRecord(key: String, value: String): Record = {
+    val map = new mutable.HashMap[String, PrimitiveTypeValue]
+    map.put(key, new StringValue(value))
+    val result = new RecordImpl(map)
+    result
+  }
+
+  def singleListRecord(key: String, value: Seq[String]): Record = {
+    val map = new mutable.HashMap[String, PrimitiveTypeValue]
+    map.put(key, new ParameterizedListValue(StringType(), value.map(x => new StringValue(x))))
+    val result = new RecordImpl(map)
+    result
+  }
+
+  def prefixMapRecord(key: String, value: PrefixMap): Record = {
+    val map = new mutable.HashMap[String, PrimitiveTypeValue]
+    value.getKeysAsStream
+      .foreach(prefixKey => map.put(prefixKey.toASCIIString, new URIValue(value.get(prefixKey).get)))
+    val result = new RecordImpl(map)
+    result
+  }
+
+
+  private def getTypeEntry(typeName: String): PrimitiveTypeValue = {
+    new StringValue(typeName)
+  }
+
+  private def getDefEntry(table: Table): PrimitiveTypeValue = {
+    val list = table.getType.getFields
+      .map(key => key + ParserConstant.TypeSign + table.getType.getFieldType(key).get)
+      .map(x => new StringValue(x))
+    new ParameterizedListValue(StringType(), list)
+  }
+
+  private def getPrefixEntry(table: Table): PrimitiveTypeValue = {
+    val list = table.getPrefixMap.getKeysAsStream
+      .map(key => key + ParserConstant.TypeSign + table.getPrefixMap.get(key).get)
+      .map(x => new StringValue(x))
+    new ParameterizedListValue(StringType(), list)
+  }
+
+  private def getOrderEntry(table: Table): PrimitiveTypeValue = {
+    val list = table.getSortingOrder
+      .map(elem => {
+        val prefix = if (table.getFieldsWithReverseOrder.contains(elem)) {
+          ParserConstant.ReverseOrderSign
+        } else {
+          ParserConstant.StandardOrderSign
+        }
+        prefix + elem
+      })
+      .map(x => StringValue(x))
+    new ParameterizedListValue(StringType(), list)
+  }
+
+  def renderMetadata(output: UncheckedWriter, typeName: String, table: Table): Unit = {
+    val map = new mutable.HashMap[String, PrimitiveTypeValue]
+    map.put(ParserConstant.TypeSelectionToken, getTypeEntry(typeName))
+    map.put(ParserConstant.TypeDefinitionToken, getDefEntry(table))
+    map.put(ParserConstant.PrefixMapToken, getPrefixEntry(table))
+    map.put(ParserConstant.SortingOrderDeclarationToken, getOrderEntry(table))
+
+    val record = new RecordImpl(map)
+    render(output, record, MetadataTokens)
+    output.write(NewLine + NewLine)
+  }
+
   def renderAllRecords(output: UncheckedWriter, table: CompositeTypeValue): Unit = {
     val list: Seq[Record] = table.getRecords
     list.indices.foreach(index => {
@@ -133,11 +206,11 @@ class YamlRenderer(output: Writer) extends Renderer {
     })
   }
 
-
   def render(output: UncheckedWriter, tableMap: TableMap): Unit = {
     output.write(NewLine + NewLine)
     tableMap.getTableIds.foreach(tableId => {
       val table: Table = tableMap.getTable(tableId).get
+      renderMetadata(output, tableId, table)
       renderAllRecords(output, table)
     })
     output.write(NewLine + NewLine)