diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt index 7f4875a3b54..24a32ced6dd 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt @@ -523,18 +523,18 @@ public class IncrementalCacheImpl( override fun dumpValue(value: Boolean) = "" } - private inner class MultifileClassFacadeMap(storageFile: File) : BasicStringMap>(storageFile, StringListExternalizer) { - public fun add(facadeName: JvmClassName, partNames: List) { + private inner class MultifileClassFacadeMap(storageFile: File) : BasicStringMap>(storageFile, StringCollectionExternalizer) { + public fun add(facadeName: JvmClassName, partNames: Collection) { storage[facadeName.internalName] = partNames } - public fun getMultifileClassParts(facadeName: String): List? = storage[facadeName] + public fun getMultifileClassParts(facadeName: String): Collection? = storage[facadeName] public fun remove(className: JvmClassName) { storage.remove(className.internalName) } - override fun dumpValue(value: List): String = value.toString() + override fun dumpValue(value: Collection): String = value.dumpCollection() } private inner class MultifileClassPartMap(storageFile: File) : BasicStringMap(storageFile, EnumeratorStringDescriptor.INSTANCE) { @@ -553,7 +553,7 @@ public class IncrementalCacheImpl( override fun dumpValue(value: String): String = value } - private inner class SourceToClassesMap(storageFile: File) : BasicStringMap>(storageFile, PathStringDescriptor.INSTANCE, StringListExternalizer) { + private inner class SourceToClassesMap(storageFile: File) : BasicStringMap>(storageFile, PathStringDescriptor.INSTANCE, StringCollectionExternalizer) { public fun clearOutputsForSource(sourceFile: File) { remove(sourceFile.absolutePath) } @@ -565,7 +565,7 @@ public class IncrementalCacheImpl( public operator fun get(sourceFile: File): Collection = storage[sourceFile.absolutePath].orEmpty().map { JvmClassName.byInternalName(it) } - override fun dumpValue(value: List) = value.toString() + override fun dumpValue(value: Collection) = value.dumpCollection() override fun clean() { storage.keys.forEach { remove(it) } @@ -594,16 +594,15 @@ public class IncrementalCacheImpl( override fun dumpValue(value: Boolean) = "" } - private inner class DirtyInlineFunctionsMap(storageFile: File) : BasicStringMap>(storageFile, StringListExternalizer) { - public fun getEntries(): Map> = + private inner class DirtyInlineFunctionsMap(storageFile: File) : BasicStringMap>(storageFile, StringCollectionExternalizer) { + public fun getEntries(): Map> = storage.keys.toMap(JvmClassName::byInternalName) { storage[it]!! } public fun put(className: JvmClassName, changedFunctions: List) { storage[className.internalName] = changedFunctions } - override fun dumpValue(value: List) = - value.dumpCollection() + override fun dumpValue(value: Collection) = value.dumpCollection() } diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/LookupMap.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/LookupMap.kt index 7bc03663fdf..e5a73bb0564 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/LookupMap.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/LookupMap.kt @@ -18,16 +18,16 @@ package org.jetbrains.kotlin.jps.incremental.storage import java.io.File -internal class LookupMap(storage: File) : BasicMap>(storage, LookupSymbolKeyDescriptor, IntSetExternalizer) { +internal class LookupMap(storage: File) : BasicMap>(storage, LookupSymbolKeyDescriptor, IntCollectionExternalizer) { override fun dumpKey(key: LookupSymbolKey): String = key.toString() - override fun dumpValue(value: Set): String = value.toString() + override fun dumpValue(value: Collection): String = value.toString() public fun add(name: String, scope: String, fileId: Int) { storage.append(LookupSymbolKey(name, scope)) { out -> out.writeInt(fileId) } } - public operator fun get(key: LookupSymbolKey): Set? = storage[key] + public operator fun get(key: LookupSymbolKey): Collection? = storage[key] public operator fun set(key: LookupSymbolKey, fileIds: Set) { storage[key] = fileIds diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/externalizers.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/externalizers.kt index 96a5071a136..9190c808011 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/externalizers.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/externalizers.kt @@ -18,11 +18,11 @@ package org.jetbrains.kotlin.jps.incremental.storage import com.intellij.openapi.util.io.FileUtil import com.intellij.util.io.DataExternalizer +import com.intellij.util.io.EnumeratorStringDescriptor import com.intellij.util.io.IOUtil import com.intellij.util.io.KeyDescriptor import gnu.trove.THashSet -import gnu.trove.TIntHashSet -import gnu.trove.decorator.TIntHashSetDecorator +import org.jetbrains.jps.incremental.storage.PathStringDescriptor import java.io.DataInput import java.io.DataInputStream import java.io.DataOutput @@ -125,44 +125,6 @@ object StringToLongMapExternalizer : StringMapExternalizer() { } } - -object StringListExternalizer : DataExternalizer> { - override fun save(output: DataOutput, value: List) { - value.forEach { IOUtil.writeUTF(output, it) } - } - - override fun read(input: DataInput): List { - val result = ArrayList() - - while ((input as DataInputStream).available() > 0) { - result.add(IOUtil.readUTF(input)) - } - - return result - } -} - - -object PathCollectionExternalizer : DataExternalizer> { - override fun save(output: DataOutput, value: Collection) { - for (str in value) { - IOUtil.writeUTF(output, str) - } - } - - override fun read(input: DataInput): Collection { - val result = THashSet(FileUtil.PATH_HASHING_STRATEGY) - val stream = input as DataInputStream - - while (stream.available() > 0) { - val str = IOUtil.readUTF(stream) - result.add(str) - } - - return result - } -} - object ConstantsMapExternalizer : DataExternalizer> { override fun save(output: DataOutput, map: Map?) { output.writeInt(map!!.size()) @@ -222,25 +184,6 @@ object ConstantsMapExternalizer : DataExternalizer> { } } - -object IntSetExternalizer : DataExternalizer> { - override fun save(output: DataOutput, value: Set) { - value.forEach { output.writeInt(it) } - } - - override fun read(input: DataInput): Set { - val result = TIntHashSet() - val stream = input as DataInputStream - - while (stream.available() > 0) { - val str = stream.readInt() - result.add(str) - } - - return TIntHashSetDecorator(result) - } -} - object IntExternalizer : DataExternalizer { override fun read(input: DataInput): Int = input.readInt() @@ -261,4 +204,30 @@ object FileKeyDescriptor : KeyDescriptor { override fun isEqual(val1: File?, val2: File?): Boolean = FileUtil.FILE_HASHING_STRATEGY.equals(val1, val2) -} \ No newline at end of file +} + +open class CollectionExternalizer( + private val elementExternalizer: DataExternalizer, + private val newCollection: ()->MutableCollection +) : DataExternalizer> { + override fun read(input: DataInput): Collection { + val result = newCollection() + val stream = input as DataInputStream + + while (stream.available() > 0) { + result.add(elementExternalizer.read(stream)) + } + + return result + } + + override fun save(output: DataOutput, value: Collection) { + value.forEach { elementExternalizer.save(output, it) } + } +} + +object StringCollectionExternalizer : CollectionExternalizer(EnumeratorStringDescriptor(), { HashSet() }) + +object PathCollectionExternalizer : CollectionExternalizer(PathStringDescriptor(), { THashSet(FileUtil.PATH_HASHING_STRATEGY) }) + +object IntCollectionExternalizer : CollectionExternalizer(IntExternalizer, { HashSet() })