From 20db45c3cf15606dc57acd21baf581ca9d9d7b41 Mon Sep 17 00:00:00 2001 From: Alexey Tsvetkov Date: Tue, 28 Jul 2015 15:28:48 +0300 Subject: [PATCH] Pass BasicMap storageFile using constructor It makes possible to extract BasicMap outside of IncrementalCacheImpl and use it for some maps, that share between build targets Original commit: 47019dd51f9814b0d42c1f93712689cccf6cc824 --- .../jps/incremental/IncrementalCacheImpl.kt | 44 ++++++++++--------- 1 file changed, 24 insertions(+), 20 deletions(-) diff --git a/jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt b/jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt index 4a60aaa597a..a397ff69908 100644 --- a/jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt +++ b/jps/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt @@ -114,15 +114,19 @@ public class IncrementalCacheImpl(targetDataRoot: File) : StorageOwner, Incremen } private val baseDir = File(targetDataRoot, CACHE_DIRECTORY_NAME) - private val protoMap = ProtoMap() - private val constantsMap = ConstantsMap() - private val inlineFunctionsMap = InlineFunctionsMap() - private val packagePartMap = PackagePartMap() - private val sourceToClassesMap = SourceToClassesMap() - private val classToSourcesMap = ClassToSourcesMap() - private val dirtyOutputClassesMap = DirtyOutputClassesMap() - private val dirtyInlineFunctionsMap = DirtyInlineFunctionsMap() - private val hasInlineTo = InlineFunctionsFilesMap() + + private val String.storageFile: File + get() = File(baseDir, this) + + private val protoMap = ProtoMap(PROTO_MAP.storageFile) + private val constantsMap = ConstantsMap(CONSTANTS_MAP.storageFile) + private val inlineFunctionsMap = InlineFunctionsMap(INLINE_FUNCTIONS.storageFile) + private val packagePartMap = PackagePartMap(PACKAGE_PARTS.storageFile) + private val sourceToClassesMap = SourceToClassesMap(SOURCE_TO_CLASSES.storageFile) + private val classToSourcesMap = ClassToSourcesMap(CLASS_TO_SOURCES.storageFile) + private val dirtyOutputClassesMap = DirtyOutputClassesMap(DIRTY_OUTPUT_CLASSES.storageFile) + private val dirtyInlineFunctionsMap = DirtyInlineFunctionsMap(DIRTY_INLINE_FUNCTIONS.storageFile) + private val hasInlineTo = InlineFunctionsFilesMap(HAS_INLINE_TO.storageFile) private val maps = listOf(protoMap, constantsMap, @@ -306,7 +310,7 @@ public class IncrementalCacheImpl(targetDataRoot: File) : StorageOwner, Incremen } private inner abstract class BasicMap( - private val storageName: String, + private val storageFile: File, private val valueExternalizer: DataExternalizer ) { protected open val keyDescriptor: KeyDescriptor @@ -367,10 +371,10 @@ public class IncrementalCacheImpl(targetDataRoot: File) : StorageOwner, Incremen protected abstract fun dumpValue(value: V): String private fun createMap(): PersistentHashMap = - PersistentHashMap(File(baseDir, storageName), keyDescriptor, valueExternalizer) + PersistentHashMap(storageFile, keyDescriptor, valueExternalizer) } - private inner class ProtoMap : BasicMap(PROTO_MAP, ByteArrayExternalizer) { + private inner class ProtoMap(storageFile: File) : BasicMap(storageFile, ByteArrayExternalizer) { public fun put(className: JvmClassName, data: ByteArray, isPackage: Boolean, checkChangesIsOpenPart: Boolean = true): Boolean { val key = className.getInternalName() @@ -447,7 +451,7 @@ public class IncrementalCacheImpl(targetDataRoot: File) : StorageOwner, Incremen } } - private inner class ConstantsMap : BasicMap>(CONSTANTS_MAP, ConstantsMapExternalizer) { + private inner class ConstantsMap(storageFile: File) : BasicMap>(storageFile, ConstantsMapExternalizer) { private fun getConstantsMap(bytes: ByteArray): Map? { val result = HashMap() @@ -550,7 +554,7 @@ public class IncrementalCacheImpl(targetDataRoot: File) : StorageOwner, Incremen } } - private inner class InlineFunctionsMap : BasicMap>(INLINE_FUNCTIONS, StringToLongMapExternalizer) { + private inner class InlineFunctionsMap(storageFile: File) : BasicMap>(storageFile, StringToLongMapExternalizer) { private fun getInlineFunctionsMap(bytes: ByteArray): Map { val result = HashMap() @@ -624,7 +628,7 @@ public class IncrementalCacheImpl(targetDataRoot: File) : StorageOwner, Incremen value.dumpMap { java.lang.Long.toHexString(it) } } - private inner class PackagePartMap : BasicMap(PACKAGE_PARTS, BooleanDataDescriptor.INSTANCE) { + private inner class PackagePartMap(storageFile: File) : BasicMap(storageFile, BooleanDataDescriptor.INSTANCE) { public fun addPackagePart(className: JvmClassName) { storage.put(className.getInternalName(), true) } @@ -640,7 +644,7 @@ public class IncrementalCacheImpl(targetDataRoot: File) : StorageOwner, Incremen override fun dumpValue(value: Boolean) = "" } - private inner class SourceToClassesMap : BasicMap>(SOURCE_TO_CLASSES, StringListExternalizer) { + private inner class SourceToClassesMap(storageFile: File) : BasicMap>(storageFile, StringListExternalizer) { override val keyDescriptor: KeyDescriptor get() = PathStringDescriptor.INSTANCE @@ -659,7 +663,7 @@ public class IncrementalCacheImpl(targetDataRoot: File) : StorageOwner, Incremen override fun dumpValue(value: List) = value.toString() } - private inner class ClassToSourcesMap : BasicMap>(CLASS_TO_SOURCES, PathCollectionExternalizer) { + private inner class ClassToSourcesMap(storageFile: File) : BasicMap>(storageFile, PathCollectionExternalizer) { public fun get(className: JvmClassName): Collection = storage[className.internalName] ?: emptySet() @@ -677,7 +681,7 @@ public class IncrementalCacheImpl(targetDataRoot: File) : StorageOwner, Incremen value.dumpCollection() } - private inner class DirtyOutputClassesMap : BasicMap(DIRTY_OUTPUT_CLASSES, BooleanDataDescriptor.INSTANCE) { + private inner class DirtyOutputClassesMap(storageFile: File) : BasicMap(storageFile, BooleanDataDescriptor.INSTANCE) { public fun markDirty(className: String) { storage.put(className, true) } @@ -693,7 +697,7 @@ public class IncrementalCacheImpl(targetDataRoot: File) : StorageOwner, Incremen override fun dumpValue(value: Boolean) = "" } - private inner class DirtyInlineFunctionsMap : BasicMap>(DIRTY_INLINE_FUNCTIONS, StringListExternalizer) { + private inner class DirtyInlineFunctionsMap(storageFile: File) : BasicMap>(storageFile, StringListExternalizer) { public fun getEntries(): Map> = storage.allKeysWithExistingMapping .toMap(JvmClassName::byInternalName) { storage[it] } @@ -714,7 +718,7 @@ public class IncrementalCacheImpl(targetDataRoot: File) : StorageOwner, Incremen * * inlineFunction - jvmSignature of some inline function in source file * * target files - collection of files inlineFunction has been inlined to */ - private inner class InlineFunctionsFilesMap : BasicMap>>(HAS_INLINE_TO, StringToPathsMapExternalizer) { + private inner class InlineFunctionsFilesMap(storageFile: File) : BasicMap>>(storageFile, StringToPathsMapExternalizer) { override val keyDescriptor: KeyDescriptor get() = PathStringDescriptor()