From cc1c5b7e10f19dac679bed5b471ae5ad090f981f Mon Sep 17 00:00:00 2001 From: Zalim Bashorov Date: Thu, 21 Jan 2016 14:59:45 +0300 Subject: [PATCH] Move back classes which used only in JPS --- .../incremental/storage/externalizers.kt | 43 +----------------- .../kotlin/incremental/storage/values.kt | 25 ----------- .../incremental/JpsIncrementalCacheImpl.kt | 10 ++++- .../jps/incremental/storages/externalizers.kt | 45 +++++++++++++++++++ .../kotlin/jps/incremental/storages/values.kt | 42 +++++++++++++++++ 5 files changed, 96 insertions(+), 69 deletions(-) create mode 100644 jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storages/externalizers.kt create mode 100644 jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storages/values.kt diff --git a/build/src/org/jetbrains/kotlin/incremental/storage/externalizers.kt b/build/src/org/jetbrains/kotlin/incremental/storage/externalizers.kt index fa9ebe38efc..f8d3f1be299 100644 --- a/build/src/org/jetbrains/kotlin/incremental/storage/externalizers.kt +++ b/build/src/org/jetbrains/kotlin/incremental/storage/externalizers.kt @@ -21,7 +21,6 @@ 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 java.io.DataInput import java.io.DataInputStream import java.io.DataOutput @@ -46,25 +45,6 @@ object LookupSymbolKeyDescriptor : KeyDescriptor { override fun isEqual(val1: LookupSymbolKey, val2: LookupSymbolKey): Boolean = val1 == val2 } - -object PathFunctionPairKeyDescriptor : KeyDescriptor { - override fun read(input: DataInput): PathFunctionPair { - val path = IOUtil.readUTF(input) - val function = IOUtil.readUTF(input) - return PathFunctionPair(path, function) - } - - override fun save(output: DataOutput, value: PathFunctionPair) { - IOUtil.writeUTF(output, value.path) - IOUtil.writeUTF(output, value.function) - } - - override fun getHashCode(value: PathFunctionPair): Int = value.hashCode() - - override fun isEqual(val1: PathFunctionPair, val2: PathFunctionPair): Boolean = val1 == val2 -} - - object ProtoMapValueExternalizer : DataExternalizer { override fun save(output: DataOutput, value: ProtoMapValue) { output.writeBoolean(value.isPackageFacade) @@ -124,27 +104,6 @@ object StringToLongMapExternalizer : StringMapExternalizer() { } } - -object PathStringCollectionExternalizer : 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) @@ -228,7 +187,7 @@ object FileKeyDescriptor : KeyDescriptor { open class CollectionExternalizer( private val elementExternalizer: DataExternalizer, - private val newCollection: ()->MutableCollection + private val newCollection: () -> MutableCollection ) : DataExternalizer> { override fun read(input: DataInput): Collection { val result = newCollection() diff --git a/build/src/org/jetbrains/kotlin/incremental/storage/values.kt b/build/src/org/jetbrains/kotlin/incremental/storage/values.kt index c86500b7fd0..32a51179e3c 100644 --- a/build/src/org/jetbrains/kotlin/incremental/storage/values.kt +++ b/build/src/org/jetbrains/kotlin/incremental/storage/values.kt @@ -16,8 +16,6 @@ package org.jetbrains.kotlin.incremental.storage -import com.intellij.openapi.util.io.FileUtil - data class LookupSymbolKey(val nameHash: Int, val scopeHash: Int) : Comparable { constructor(name: String, scope: String) : this(name.hashCode(), scope.hashCode()) @@ -30,27 +28,4 @@ data class LookupSymbolKey(val nameHash: Int, val scopeHash: Int) : Comparable { - override fun compareTo(other: PathFunctionPair): Int { - val pathComp = FileUtil.comparePaths(path, other.path) - - if (pathComp != 0) return pathComp - - return function.compareTo(other.function) - } - - override fun equals(other: Any?): Boolean = - when (other) { - is PathFunctionPair -> - FileUtil.pathsEqual(path, other.path) && function == other.function - else -> - false - } - - override fun hashCode(): Int = 31 * FileUtil.pathHashCode(path) + function.hashCode() -} - data class ProtoMapValue(val isPackageFacade: Boolean, val bytes: ByteArray, val strings: Array) diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCacheImpl.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCacheImpl.kt index 6653b066084..4616450bfb1 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCacheImpl.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCacheImpl.kt @@ -25,9 +25,15 @@ import org.jetbrains.jps.incremental.storage.BuildDataManager import org.jetbrains.jps.incremental.storage.StorageOwner import org.jetbrains.kotlin.config.IncrementalCompilation import org.jetbrains.kotlin.incremental.* -import org.jetbrains.kotlin.incremental.storage.* +import org.jetbrains.kotlin.incremental.storage.BasicMap +import org.jetbrains.kotlin.incremental.storage.BasicStringMap +import org.jetbrains.kotlin.incremental.storage.StringCollectionExternalizer +import org.jetbrains.kotlin.incremental.storage.StringToLongMapExternalizer import org.jetbrains.kotlin.inline.inlineFunctionsJvmNames import org.jetbrains.kotlin.jps.build.KotlinBuilder +import org.jetbrains.kotlin.jps.incremental.storages.PathCollectionExternalizer +import org.jetbrains.kotlin.jps.incremental.storages.PathFunctionPair +import org.jetbrains.kotlin.jps.incremental.storages.PathFunctionPairKeyDescriptor import org.jetbrains.kotlin.resolve.jvm.JvmClassName import org.jetbrains.org.objectweb.asm.* import java.io.File @@ -179,7 +185,7 @@ class JpsIncrementalCacheImpl( * * inlineFunction - jvmSignature of some inline function in source file * * target files - collection of files inlineFunction has been inlined to */ - private inner class InlineFunctionsFilesMap(storageFile: File) : BasicMap>(storageFile, PathFunctionPairKeyDescriptor, PathStringCollectionExternalizer) { + private inner class InlineFunctionsFilesMap(storageFile: File) : BasicMap>(storageFile, PathFunctionPairKeyDescriptor, PathCollectionExternalizer) { fun add(sourcePath: String, jvmSignature: String, targetPath: String) { val key = PathFunctionPair(sourcePath, jvmSignature) storage.append(key, targetPath) diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storages/externalizers.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storages/externalizers.kt new file mode 100644 index 00000000000..5625caca6fa --- /dev/null +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storages/externalizers.kt @@ -0,0 +1,45 @@ +/* + * Copyright 2010-2016 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.jps.incremental.storages + +import com.intellij.openapi.util.io.FileUtil +import com.intellij.util.io.IOUtil +import com.intellij.util.io.KeyDescriptor +import gnu.trove.THashSet +import org.jetbrains.jps.incremental.storage.PathStringDescriptor +import org.jetbrains.kotlin.incremental.storage.CollectionExternalizer +import java.io.DataInput +import java.io.DataOutput + +object PathFunctionPairKeyDescriptor : KeyDescriptor { + override fun read(input: DataInput): PathFunctionPair { + val path = IOUtil.readUTF(input) + val function = IOUtil.readUTF(input) + return PathFunctionPair(path, function) + } + + override fun save(output: DataOutput, value: PathFunctionPair) { + IOUtil.writeUTF(output, value.path) + IOUtil.writeUTF(output, value.function) + } + + override fun getHashCode(value: PathFunctionPair): Int = value.hashCode() + + override fun isEqual(val1: PathFunctionPair, val2: PathFunctionPair): Boolean = val1 == val2 +} + +object PathCollectionExternalizer : CollectionExternalizer(PathStringDescriptor(), { THashSet(FileUtil.PATH_HASHING_STRATEGY) }) diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storages/values.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storages/values.kt new file mode 100644 index 00000000000..40c633f4660 --- /dev/null +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storages/values.kt @@ -0,0 +1,42 @@ +/* + * Copyright 2010-2016 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.jps.incremental.storages + +import com.intellij.openapi.util.io.FileUtil + +class PathFunctionPair( + val path: String, + val function: String +): Comparable { + override fun compareTo(other: PathFunctionPair): Int { + val pathComp = FileUtil.comparePaths(path, other.path) + + if (pathComp != 0) return pathComp + + return function.compareTo(other.function) + } + + override fun equals(other: Any?): Boolean = + when (other) { + is PathFunctionPair -> + FileUtil.pathsEqual(path, other.path) && function == other.function + else -> + false + } + + override fun hashCode(): Int = 31 * FileUtil.pathHashCode(path) + function.hashCode() +}