code to manually recover a database file --requires OASIS classpath

Recovery.kt

package com.empowerops.front_end

import com.empowerops.common.Serializer.DataInputAdapter
import com.thoughtworks.xstream.XStream
import com.thoughtworks.xstream.io.HierarchicalStreamReader
import com.thoughtworks.xstream.io.HierarchicalStreamWriter
import com.thoughtworks.xstream.io.binary.BinaryStreamDriver
import com.thoughtworks.xstream.io.xml.PrettyPrintWriter
import com.thoughtworks.xstream.io.xml.XppDriver
import com.thoughtworks.xstream.security.WildcardTypePermission
import org.junit.Test

import org.mapdb.*;
import java.io.DataInput
import java.io.DataOutput
import java.io.File;
import java.io.StringWriter
import java.nio.file.Files
import java.nio.file.Paths
import java.util.UUID

class Recovery {

    object Deserializer: Serializer<Any>() {

        override fun serialize(out: DataOutput, value: Any?) {
            TODO("Not yet implemented")
        }

        override fun deserialize(istream: DataInput, available: Int): Any {
            val adapter = DataInputAdapter(istream)
            val driver = BinaryStreamDriver()

            val hierarchicalReader = driver.createReader(adapter)

            val writer = StringWriter()
            val hierarchicalWriter = PrettyPrintWriter(writer)

            recursiveCopy(hierarchicalReader, hierarchicalWriter)

            return writer.toString()

        }

        private fun recursiveCopy(
            hierarchicalReader: HierarchicalStreamReader,
            hierarchicalWriter: HierarchicalStreamWriter
        ) {
            //something is happening here where at the start of a node Im not properly appending a newline,
            // tbd;
            hierarchicalWriter.startNode(hierarchicalReader.nodeName)

            for(attributeName in hierarchicalReader.attributeNames){
                check(attributeName is String)
                hierarchicalWriter.addAttribute(attributeName, hierarchicalReader.getAttribute(attributeName))
            }

            hierarchicalWriter.setValue(hierarchicalReader.value)

            while(hierarchicalReader.hasMoreChildren()){
                hierarchicalReader.moveDown()
                recursiveCopy(hierarchicalReader, hierarchicalWriter)
                hierarchicalReader.moveUp()
            }

            hierarchicalWriter.endNode()
        }
    }

    @Test
    fun `when trying to recover should work correctly`(){
        val blobSerializer = XStream(BinaryStreamDriver())
        blobSerializer.setMode(XStream.NO_REFERENCES)
        blobSerializer.autodetectAnnotations(true)
        blobSerializer.addPermission(WildcardTypePermission(arrayOf("*")))

        val db = DBMaker
            .fileDB(File("C:\\Users\\geoff\\OneDrive\\Desktop\\DocumentStore.mapdb"))
            .cacheSize(1)
            .make()

        val table = db.hashMapCreate("OptimizationModel-Table").valueSerializer(Deserializer)

        val map = table.makeOrGet<UUID, String>()

        val builder = StringBuilder()

        for(key in map.keys){
            builder.appendLine(map[key])
        }

        Files
            .newBufferedWriter(Paths.get("C:\\Users\\geoff\\OneDrive\\Desktop\\DocumentStore.xml"))
            .append(builder)

    }
}