| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * |
| * 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 androidx.room.ext |
| |
| import androidx.room.compiler.codegen.CodeLanguage |
| import androidx.room.compiler.codegen.VisibilityModifier |
| import androidx.room.compiler.codegen.XClassName |
| import androidx.room.compiler.codegen.XCodeBlock |
| import androidx.room.compiler.codegen.XFunSpec |
| import androidx.room.compiler.codegen.XFunSpec.Builder.Companion.apply |
| import androidx.room.compiler.codegen.XMemberName.Companion.companionMember |
| import androidx.room.compiler.codegen.XMemberName.Companion.packageMember |
| import androidx.room.compiler.codegen.XTypeName |
| import androidx.room.compiler.codegen.XTypeSpec |
| import androidx.room.compiler.codegen.asClassName |
| import androidx.room.compiler.codegen.asMutableClassName |
| import com.squareup.kotlinpoet.javapoet.JTypeName |
| import java.util.concurrent.Callable |
| |
| object SupportDbTypeNames { |
| val DB = XClassName.get("$SQLITE_PACKAGE.db", "SupportSQLiteDatabase") |
| val SQLITE_STMT = XClassName.get("$SQLITE_PACKAGE.db", "SupportSQLiteStatement") |
| val SQLITE_OPEN_HELPER = XClassName.get("$SQLITE_PACKAGE.db", "SupportSQLiteOpenHelper") |
| val SQLITE_OPEN_HELPER_CALLBACK = |
| XClassName.get("$SQLITE_PACKAGE.db", "SupportSQLiteOpenHelper", "Callback") |
| val SQLITE_OPEN_HELPER_CONFIG = |
| XClassName.get("$SQLITE_PACKAGE.db", "SupportSQLiteOpenHelper", "Configuration") |
| val QUERY = XClassName.get("$SQLITE_PACKAGE.db", "SupportSQLiteQuery") |
| } |
| |
| object RoomTypeNames { |
| val STRING_UTIL = XClassName.get("$ROOM_PACKAGE.util", "StringUtil") |
| val ROOM_DB = XClassName.get(ROOM_PACKAGE, "RoomDatabase") |
| val ROOM_DB_KT = XClassName.get(ROOM_PACKAGE, "RoomDatabaseKt") |
| val ROOM_DB_CALLBACK = XClassName.get(ROOM_PACKAGE, "RoomDatabase", "Callback") |
| val ROOM_DB_CONFIG = XClassName.get(ROOM_PACKAGE, "DatabaseConfiguration") |
| val INSERTION_ADAPTER = XClassName.get(ROOM_PACKAGE, "EntityInsertionAdapter") |
| val UPSERTION_ADAPTER = XClassName.get(ROOM_PACKAGE, "EntityUpsertionAdapter") |
| val DELETE_OR_UPDATE_ADAPTER = XClassName.get(ROOM_PACKAGE, "EntityDeletionOrUpdateAdapter") |
| val SHARED_SQLITE_STMT = XClassName.get(ROOM_PACKAGE, "SharedSQLiteStatement") |
| val INVALIDATION_TRACKER = XClassName.get(ROOM_PACKAGE, "InvalidationTracker") |
| val ROOM_SQL_QUERY = XClassName.get(ROOM_PACKAGE, "RoomSQLiteQuery") |
| val OPEN_HELPER = XClassName.get(ROOM_PACKAGE, "RoomOpenHelper") |
| val OPEN_HELPER_DELEGATE = XClassName.get(ROOM_PACKAGE, "RoomOpenHelper", "Delegate") |
| val OPEN_HELPER_VALIDATION_RESULT = |
| XClassName.get(ROOM_PACKAGE, "RoomOpenHelper", "ValidationResult") |
| val TABLE_INFO = XClassName.get("$ROOM_PACKAGE.util", "TableInfo") |
| val TABLE_INFO_COLUMN = XClassName.get("$ROOM_PACKAGE.util", "TableInfo", "Column") |
| val TABLE_INFO_FOREIGN_KEY = XClassName.get("$ROOM_PACKAGE.util", "TableInfo", "ForeignKey") |
| val TABLE_INFO_INDEX = |
| XClassName.get("$ROOM_PACKAGE.util", "TableInfo", "Index") |
| val FTS_TABLE_INFO = XClassName.get("$ROOM_PACKAGE.util", "FtsTableInfo") |
| val VIEW_INFO = XClassName.get("$ROOM_PACKAGE.util", "ViewInfo") |
| val LIMIT_OFFSET_DATA_SOURCE = XClassName.get("$ROOM_PACKAGE.paging", "LimitOffsetDataSource") |
| val DB_UTIL = XClassName.get("$ROOM_PACKAGE.util", "DBUtil") |
| val CURSOR_UTIL = XClassName.get("$ROOM_PACKAGE.util", "CursorUtil") |
| val MIGRATION = XClassName.get("$ROOM_PACKAGE.migration", "Migration") |
| val AUTO_MIGRATION_SPEC = XClassName.get("$ROOM_PACKAGE.migration", "AutoMigrationSpec") |
| val UUID_UTIL = XClassName.get("$ROOM_PACKAGE.util", "UUIDUtil") |
| val AMBIGUOUS_COLUMN_RESOLVER = XClassName.get(ROOM_PACKAGE, "AmbiguousColumnResolver") |
| val RELATION_UTIL = XClassName.get("androidx.room.util", "RelationUtil") |
| } |
| |
| object RoomAnnotationTypeNames { |
| val QUERY = XClassName.get(ROOM_PACKAGE, "Query") |
| val DAO = XClassName.get(ROOM_PACKAGE, "Dao") |
| val DATABASE = XClassName.get(ROOM_PACKAGE, "Database") |
| val PRIMARY_KEY = XClassName.get(ROOM_PACKAGE, "PrimaryKey") |
| val TYPE_CONVERTERS = XClassName.get(ROOM_PACKAGE, "TypeConverters") |
| val TYPE_CONVERTER = XClassName.get(ROOM_PACKAGE, "TypeConverter") |
| val ENTITY = XClassName.get(ROOM_PACKAGE, "Entity") |
| } |
| |
| object PagingTypeNames { |
| val DATA_SOURCE = XClassName.get(PAGING_PACKAGE, "DataSource") |
| val POSITIONAL_DATA_SOURCE = XClassName.get(PAGING_PACKAGE, "PositionalDataSource") |
| val DATA_SOURCE_FACTORY = XClassName.get(PAGING_PACKAGE, "DataSource", "Factory") |
| val PAGING_SOURCE = XClassName.get(PAGING_PACKAGE, "PagingSource") |
| val LISTENABLE_FUTURE_PAGING_SOURCE = |
| XClassName.get(PAGING_PACKAGE, "ListenableFuturePagingSource") |
| val RX2_PAGING_SOURCE = |
| XClassName.get("$PAGING_PACKAGE.rxjava2", "RxPagingSource") |
| val RX3_PAGING_SOURCE = |
| XClassName.get("$PAGING_PACKAGE.rxjava3", "RxPagingSource") |
| } |
| |
| object LifecyclesTypeNames { |
| val LIVE_DATA = XClassName.get(LIFECYCLE_PACKAGE, "LiveData") |
| val COMPUTABLE_LIVE_DATA = XClassName.get( |
| LIFECYCLE_PACKAGE, |
| "ComputableLiveData" |
| ) |
| } |
| |
| object AndroidTypeNames { |
| val CURSOR = XClassName.get("android.database", "Cursor") |
| val BUILD = XClassName.get("android.os", "Build") |
| val CANCELLATION_SIGNAL = XClassName.get("android.os", "CancellationSignal") |
| } |
| |
| object CollectionTypeNames { |
| val ARRAY_MAP = XClassName.get(COLLECTION_PACKAGE, "ArrayMap") |
| val LONG_SPARSE_ARRAY = XClassName.get(COLLECTION_PACKAGE, "LongSparseArray") |
| val INT_SPARSE_ARRAY = XClassName.get(COLLECTION_PACKAGE, "SparseArrayCompat") |
| } |
| |
| object KotlinCollectionMemberNames { |
| val ARRAY_OF_NULLS = XClassName.get("kotlin", "LibraryKt") |
| .packageMember("arrayOfNulls") |
| } |
| |
| object CommonTypeNames { |
| val VOID = Void::class.asClassName() |
| val COLLECTION = Collection::class.asClassName() |
| val COLLECTIONS = XClassName.get("java.util", "Collections") |
| val ARRAYS = XClassName.get("java.util", "Arrays") |
| val LIST = List::class.asClassName() |
| val MUTABLE_LIST = List::class.asMutableClassName() |
| val ARRAY_LIST = XClassName.get("java.util", "ArrayList") |
| val MAP = Map::class.asClassName() |
| val MUTABLE_MAP = Map::class.asMutableClassName() |
| val HASH_MAP = XClassName.get("java.util", "HashMap") |
| val QUEUE = XClassName.get("java.util", "Queue") |
| val LINKED_HASH_MAP = LinkedHashMap::class.asClassName() |
| val SET = Set::class.asClassName() |
| val MUTABLE_SET = Set::class.asMutableClassName() |
| val HASH_SET = XClassName.get("java.util", "HashSet") |
| val STRING = String::class.asClassName() |
| val STRING_BUILDER = XClassName.get("java.lang", "StringBuilder") |
| val OPTIONAL = XClassName.get("java.util", "Optional") |
| val UUID = XClassName.get("java.util", "UUID") |
| val BYTE_BUFFER = XClassName.get("java.nio", "ByteBuffer") |
| val JAVA_CLASS = XClassName.get("java.lang", "Class") |
| val CALLABLE = Callable::class.asClassName() |
| val DATE = XClassName.get("java.util", "Date") |
| } |
| |
| object ExceptionTypeNames { |
| val ILLEGAL_STATE_EXCEPTION = IllegalStateException::class.asClassName() |
| val ILLEGAL_ARG_EXCEPTION = IllegalArgumentException::class.asClassName() |
| } |
| |
| object GuavaTypeNames { |
| val OPTIONAL = XClassName.get("com.google.common.base", "Optional") |
| val IMMUTABLE_MULTIMAP_BUILDER = XClassName.get( |
| "com.google.common.collect", |
| "ImmutableMultimap", |
| "Builder" |
| ) |
| val IMMUTABLE_SET_MULTIMAP = XClassName.get( |
| "com.google.common.collect", |
| "ImmutableSetMultimap" |
| ) |
| val IMMUTABLE_SET_MULTIMAP_BUILDER = XClassName.get( |
| "com.google.common.collect", |
| "ImmutableSetMultimap", |
| "Builder" |
| ) |
| val IMMUTABLE_LIST_MULTIMAP = XClassName.get( |
| "com.google.common.collect", |
| "ImmutableListMultimap" |
| ) |
| val IMMUTABLE_LIST_MULTIMAP_BUILDER = XClassName.get( |
| "com.google.common.collect", |
| "ImmutableListMultimap", |
| "Builder" |
| ) |
| val IMMUTABLE_MAP = XClassName.get("com.google.common.collect", "ImmutableMap") |
| val IMMUTABLE_LIST = XClassName.get("com.google.common.collect", "ImmutableList") |
| val IMMUTABLE_LIST_BUILDER = XClassName.get( |
| "com.google.common.collect", |
| "ImmutableList", |
| "Builder" |
| ) |
| } |
| |
| object GuavaUtilConcurrentTypeNames { |
| val LISTENABLE_FUTURE = XClassName.get("com.google.common.util.concurrent", "ListenableFuture") |
| } |
| |
| object RxJava2TypeNames { |
| val FLOWABLE = XClassName.get("io.reactivex", "Flowable") |
| val OBSERVABLE = XClassName.get("io.reactivex", "Observable") |
| val MAYBE = XClassName.get("io.reactivex", "Maybe") |
| val SINGLE = XClassName.get("io.reactivex", "Single") |
| val COMPLETABLE = XClassName.get("io.reactivex", "Completable") |
| } |
| |
| object RxJava3TypeNames { |
| val FLOWABLE = XClassName.get("io.reactivex.rxjava3.core", "Flowable") |
| val OBSERVABLE = XClassName.get("io.reactivex.rxjava3.core", "Observable") |
| val MAYBE = XClassName.get("io.reactivex.rxjava3.core", "Maybe") |
| val SINGLE = XClassName.get("io.reactivex.rxjava3.core", "Single") |
| val COMPLETABLE = XClassName.get("io.reactivex.rxjava3.core", "Completable") |
| } |
| |
| object ReactiveStreamsTypeNames { |
| val PUBLISHER = XClassName.get("org.reactivestreams", "Publisher") |
| } |
| |
| object RoomGuavaTypeNames { |
| val GUAVA_ROOM = XClassName.get("$ROOM_PACKAGE.guava", "GuavaRoom") |
| } |
| |
| object RoomRxJava2TypeNames { |
| val RX_ROOM = XClassName.get(ROOM_PACKAGE, "RxRoom") |
| val RX_ROOM_CREATE_FLOWABLE = "createFlowable" |
| val RX_ROOM_CREATE_OBSERVABLE = "createObservable" |
| val RX_EMPTY_RESULT_SET_EXCEPTION = XClassName.get(ROOM_PACKAGE, "EmptyResultSetException") |
| } |
| |
| object RoomRxJava3TypeNames { |
| val RX_ROOM = XClassName.get("$ROOM_PACKAGE.rxjava3", "RxRoom") |
| val RX_ROOM_CREATE_FLOWABLE = "createFlowable" |
| val RX_ROOM_CREATE_OBSERVABLE = "createObservable" |
| val RX_EMPTY_RESULT_SET_EXCEPTION = |
| XClassName.get("$ROOM_PACKAGE.rxjava3", "EmptyResultSetException") |
| } |
| |
| object RoomPagingTypeNames { |
| val LIMIT_OFFSET_PAGING_SOURCE = XClassName.get( |
| "$ROOM_PACKAGE.paging", "LimitOffsetPagingSource" |
| ) |
| } |
| |
| object RoomPagingGuavaTypeNames { |
| val LIMIT_OFFSET_LISTENABLE_FUTURE_PAGING_SOURCE = XClassName.get( |
| "$ROOM_PACKAGE.paging.guava", |
| "LimitOffsetListenableFuturePagingSource" |
| ) |
| } |
| |
| object RoomPagingRx2TypeNames { |
| val LIMIT_OFFSET_RX_PAGING_SOURCE = XClassName.get( |
| "$ROOM_PACKAGE.paging.rxjava2", |
| "LimitOffsetRxPagingSource" |
| ) |
| } |
| |
| object RoomPagingRx3TypeNames { |
| val LIMIT_OFFSET_RX_PAGING_SOURCE = XClassName.get( |
| "$ROOM_PACKAGE.paging.rxjava3", |
| "LimitOffsetRxPagingSource" |
| ) |
| } |
| |
| object RoomCoroutinesTypeNames { |
| val COROUTINES_ROOM = XClassName.get(ROOM_PACKAGE, "CoroutinesRoom") |
| } |
| |
| object KotlinTypeNames { |
| val ANY = Any::class.asClassName() |
| val UNIT = XClassName.get("kotlin", "Unit") |
| val CONTINUATION = XClassName.get("kotlin.coroutines", "Continuation") |
| val CHANNEL = XClassName.get("kotlinx.coroutines.channels", "Channel") |
| val RECEIVE_CHANNEL = XClassName.get("kotlinx.coroutines.channels", "ReceiveChannel") |
| val SEND_CHANNEL = XClassName.get("kotlinx.coroutines.channels", "SendChannel") |
| val FLOW = XClassName.get("kotlinx.coroutines.flow", "Flow") |
| val LAZY = XClassName.get("kotlin", "Lazy") |
| } |
| |
| object RoomMemberNames { |
| val DB_UTIL_QUERY = RoomTypeNames.DB_UTIL.packageMember("query") |
| val DB_UTIL_DROP_FTS_SYNC_TRIGGERS = RoomTypeNames.DB_UTIL.packageMember("dropFtsSyncTriggers") |
| val CURSOR_UTIL_GET_COLUMN_INDEX = |
| RoomTypeNames.CURSOR_UTIL.packageMember("getColumnIndex") |
| val CURSOR_UTIL_GET_COLUMN_INDEX_OR_THROW = |
| RoomTypeNames.CURSOR_UTIL.packageMember("getColumnIndexOrThrow") |
| val CURSOR_UTIL_WRAP_MAPPED_COLUMNS = |
| RoomTypeNames.CURSOR_UTIL.packageMember("wrapMappedColumns") |
| val ROOM_SQL_QUERY_ACQUIRE = |
| RoomTypeNames.ROOM_SQL_QUERY.companionMember("acquire", isJvmStatic = true) |
| val ROOM_DATABASE_WITH_TRANSACTION = |
| RoomTypeNames.ROOM_DB_KT.packageMember("withTransaction") |
| val TABLE_INFO_READ = |
| RoomTypeNames.TABLE_INFO.companionMember("read", isJvmStatic = true) |
| val FTS_TABLE_INFO_READ = |
| RoomTypeNames.FTS_TABLE_INFO.companionMember("read", isJvmStatic = true) |
| val VIEW_INFO_READ = |
| RoomTypeNames.VIEW_INFO.companionMember("read", isJvmStatic = true) |
| } |
| |
| val DEFERRED_TYPES = listOf( |
| LifecyclesTypeNames.LIVE_DATA, |
| LifecyclesTypeNames.COMPUTABLE_LIVE_DATA, |
| RxJava2TypeNames.FLOWABLE, |
| RxJava2TypeNames.OBSERVABLE, |
| RxJava2TypeNames.MAYBE, |
| RxJava2TypeNames.SINGLE, |
| RxJava2TypeNames.COMPLETABLE, |
| RxJava3TypeNames.FLOWABLE, |
| RxJava3TypeNames.OBSERVABLE, |
| RxJava3TypeNames.MAYBE, |
| RxJava3TypeNames.SINGLE, |
| RxJava3TypeNames.COMPLETABLE, |
| GuavaUtilConcurrentTypeNames.LISTENABLE_FUTURE, |
| KotlinTypeNames.FLOW, |
| ReactiveStreamsTypeNames.PUBLISHER |
| ) |
| |
| fun XTypeName.defaultValue(): String { |
| return if (!isPrimitive) { |
| "null" |
| } else if (this == XTypeName.PRIMITIVE_BOOLEAN) { |
| "false" |
| } else { |
| "0" |
| } |
| } |
| |
| fun CallableTypeSpecBuilder( |
| language: CodeLanguage, |
| parameterTypeName: XTypeName, |
| callBody: XFunSpec.Builder.() -> Unit |
| ) = XTypeSpec.anonymousClassBuilder(language, "").apply { |
| addSuperinterface(CommonTypeNames.CALLABLE.parametrizedBy(parameterTypeName)) |
| addFunction( |
| XFunSpec.builder( |
| language = language, |
| name = "call", |
| visibility = VisibilityModifier.PUBLIC, |
| isOverride = true |
| ).apply { |
| returns(parameterTypeName) |
| callBody() |
| }.apply( |
| javaMethodBuilder = { |
| addException(JTypeName.get(Exception::class.java)) |
| }, |
| kotlinFunctionBuilder = { } |
| ).build() |
| ) |
| } |
| |
| fun Function1TypeSpec( |
| language: CodeLanguage, |
| parameterTypeName: XTypeName, |
| parameterName: String, |
| returnTypeName: XTypeName, |
| callBody: XFunSpec.Builder.() -> Unit |
| ) = XTypeSpec.anonymousClassBuilder(language, "").apply { |
| superclass( |
| Function1::class.asClassName().parametrizedBy(parameterTypeName, returnTypeName) |
| ) |
| addFunction( |
| XFunSpec.builder( |
| language = language, |
| name = "invoke", |
| visibility = VisibilityModifier.PUBLIC, |
| isOverride = true |
| ).apply { |
| addParameter(parameterTypeName, parameterName) |
| returns(returnTypeName) |
| callBody() |
| }.build() |
| ) |
| }.build() |
| |
| /** |
| * Generates an array literal with the given [values] |
| * |
| * Example: `ArrayLiteral(XTypeName.PRIMITIVE_INT, 1, 2, 3)` |
| * |
| * For Java will produce: `new int[] {1, 2, 3}` |
| * |
| * For Kotlin will produce: `intArrayOf(1, 2, 3)`, |
| */ |
| fun ArrayLiteral( |
| language: CodeLanguage, |
| type: XTypeName, |
| vararg values: Any |
| ): XCodeBlock { |
| val space = when (language) { |
| CodeLanguage.JAVA -> "%W" |
| CodeLanguage.KOTLIN -> " " |
| } |
| val initExpr = when (language) { |
| CodeLanguage.JAVA -> XCodeBlock.of(language, "new %T[] ", type) |
| CodeLanguage.KOTLIN -> XCodeBlock.of(language, getArrayOfFunction(type)) |
| } |
| val openingChar = when (language) { |
| CodeLanguage.JAVA -> "{" |
| CodeLanguage.KOTLIN -> "(" |
| } |
| val closingChar = when (language) { |
| CodeLanguage.JAVA -> "}" |
| CodeLanguage.KOTLIN -> ")" |
| } |
| return XCodeBlock.of( |
| language, |
| "%L$openingChar%L$closingChar", |
| initExpr, |
| XCodeBlock.builder(language).apply { |
| val joining = Array(values.size) { i -> |
| XCodeBlock.of( |
| language, |
| if (type == CommonTypeNames.STRING) "%S" else "%L", |
| values[i] |
| ) |
| } |
| val placeholders = joining.joinToString(separator = ",$space") { "%L" } |
| add(placeholders, *joining) |
| }.build() |
| ) |
| } |
| |
| /** |
| * Generates a 2D array literal where the value at `i`,`j` will be produced by `valueProducer. |
| * For example: |
| * ``` |
| * DoubleArrayLiteral(XTypeName.PRIMITIVE_INT, 2, { _ -> 3 }, { i, j -> i + j }) |
| * ``` |
| * For Java will produce: |
| * ``` |
| * new int[][] { |
| * {0, 1, 2}, |
| * {1, 2, 3} |
| * } |
| * ``` |
| * For Kotlin will produce: |
| * ``` |
| * arrayOf( |
| * intArrayOf(0, 1, 2), |
| * intArrayOf(1, 2, 3) |
| * ) |
| * ``` |
| */ |
| fun DoubleArrayLiteral( |
| language: CodeLanguage, |
| type: XTypeName, |
| rowSize: Int, |
| columnSizeProducer: (Int) -> Int, |
| valueProducer: (Int, Int) -> Any |
| ): XCodeBlock { |
| val space = when (language) { |
| CodeLanguage.JAVA -> "%W" |
| CodeLanguage.KOTLIN -> " " |
| } |
| val outerInit = when (language) { |
| CodeLanguage.JAVA -> XCodeBlock.of(language, "new %T[][] ", type) |
| CodeLanguage.KOTLIN -> XCodeBlock.of(language, "arrayOf") |
| } |
| val innerInit = when (language) { |
| CodeLanguage.JAVA -> XCodeBlock.of(language, "", type) |
| CodeLanguage.KOTLIN -> XCodeBlock.of(language, getArrayOfFunction(type)) |
| } |
| val openingChar = when (language) { |
| CodeLanguage.JAVA -> "{" |
| CodeLanguage.KOTLIN -> "(" |
| } |
| val closingChar = when (language) { |
| CodeLanguage.JAVA -> "}" |
| CodeLanguage.KOTLIN -> ")" |
| } |
| return XCodeBlock.of( |
| language, |
| "%L$openingChar%L$closingChar", |
| outerInit, |
| XCodeBlock.builder(language).apply { |
| val joining = Array(rowSize) { i -> |
| XCodeBlock.of( |
| language, |
| "%L$openingChar%L$closingChar", |
| innerInit, |
| XCodeBlock.builder(language).apply { |
| val joining = Array(columnSizeProducer(i)) { j -> |
| XCodeBlock.of( |
| language, |
| if (type == CommonTypeNames.STRING) "%S" else "%L", |
| valueProducer(i, j) |
| ) |
| } |
| val placeholders = joining.joinToString(separator = ",$space") { "%L" } |
| add(placeholders, *joining) |
| }.build() |
| ) |
| } |
| val placeholders = joining.joinToString(separator = ",$space") { "%L" } |
| add(placeholders, *joining) |
| }.build() |
| ) |
| } |
| |
| private fun getArrayOfFunction(type: XTypeName) = when (type) { |
| XTypeName.PRIMITIVE_BOOLEAN -> "booleanArrayOf" |
| XTypeName.PRIMITIVE_BYTE -> "byteArrayOf" |
| XTypeName.PRIMITIVE_SHORT -> "shortArrayOf" |
| XTypeName.PRIMITIVE_INT -> "intArrayOf" |
| XTypeName.PRIMITIVE_LONG -> "longArrayOf" |
| XTypeName.PRIMITIVE_CHAR -> "charArrayOf" |
| XTypeName.PRIMITIVE_FLOAT -> "floatArrayOf" |
| XTypeName.PRIMITIVE_DOUBLE -> "doubleArrayOf" |
| else -> "arrayOf" |
| } |
| |
| fun getToArrayFunction(type: XTypeName) = when (type) { |
| XTypeName.PRIMITIVE_BOOLEAN -> "toBooleanArray()" |
| XTypeName.PRIMITIVE_BYTE -> "toByteArray()" |
| XTypeName.PRIMITIVE_SHORT -> "toShortArray()" |
| XTypeName.PRIMITIVE_INT -> "toIntArray()" |
| XTypeName.PRIMITIVE_LONG -> "toLongArray()" |
| XTypeName.PRIMITIVE_CHAR -> "toCharArray()" |
| XTypeName.PRIMITIVE_FLOAT -> "toFloatArray()" |
| XTypeName.PRIMITIVE_DOUBLE -> "toDoubleArray()" |
| else -> error("Provided type expected to be primitive. Found: $type") |
| } |
| |
| /** |
| * Code of expression for [Collection.size] in Kotlin, and [java.util.Collection.size] for Java. |
| */ |
| fun CollectionsSizeExprCode(language: CodeLanguage, varName: String) = XCodeBlock.of( |
| language, |
| when (language) { |
| CodeLanguage.JAVA -> "%L.size()" // java.util.Collections.size() |
| CodeLanguage.KOTLIN -> "%L.size" // kotlin.collections.Collection.size |
| }, |
| varName |
| ) |
| |
| /** |
| * Code of expression for [Array.size] in Kotlin, and `arr.length` for Java. |
| */ |
| fun ArraySizeExprCode(language: CodeLanguage, varName: String) = XCodeBlock.of( |
| language, |
| when (language) { |
| CodeLanguage.JAVA -> "%L.length" // Just `arr.length` |
| CodeLanguage.KOTLIN -> "%L.size" // kotlin.Array.size and primitives (e.g. IntArray) |
| }, |
| varName |
| ) |
| |
| /** |
| * Code of expression for [Map.keys] in Kotlin, and [java.util.Map.keySet] for Java. |
| */ |
| fun MapKeySetExprCode(language: CodeLanguage, varName: String) = XCodeBlock.of( |
| language, |
| when (language) { |
| CodeLanguage.JAVA -> "%L.keySet()" // java.util.Map.keySet() |
| CodeLanguage.KOTLIN -> "%L.keys" // kotlin.collections.Map.keys |
| }, |
| varName |
| ) |
