path
stringlengths 4
280
| owner
stringlengths 2
39
| repo_id
int64 21.1k
879M
| is_fork
bool 2
classes | languages_distribution
stringlengths 13
1.95k
⌀ | content
stringlengths 7
482k
| issues
int64 0
13.9k
| main_language
stringclasses 121
values | forks
stringlengths 1
5
| stars
int64 0
111k
| commit_sha
stringlengths 40
40
| size
int64 7
482k
| name
stringlengths 1
100
| license
stringclasses 93
values |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
app/src/main/java/com/example/nordicnews/data/NordicNewsDatabase.kt | avanisoam | 803,286,041 | false | {"Kotlin": 160121} | package com.example.nordicnews.data
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import androidx.room.TypeConverters
import com.example.nordicnews.data.models.Article
/**
* Database class with a singleton Instance object.
*/
@Database(entities = arrayOf(Article::class), version = 1, exportSchema = false)
@TypeConverters(ArticleTypeConvertor::class)
abstract class NordicNewsDatabase : RoomDatabase() {
abstract fun articleDao(): ArticleDao
companion object {
@Volatile
private var Instance: NordicNewsDatabase? = null
fun getDatabase(context: Context): NordicNewsDatabase {
// if the Instance is not null, return it, otherwise create a new database instance.
return Instance ?: synchronized(this) {
Room.databaseBuilder(context, NordicNewsDatabase::class.java, "nordicnews_database")
.addTypeConverter(ArticleTypeConvertor())
.build()
.also { Instance = it }
}
}
}
} | 0 | Kotlin | 0 | 0 | 07b072261bf7b172745e189fedcf2d017bbb9c51 | 1,107 | NordicNews | MIT License |
domain/src/main/java/tachiyomi/domain/history/manga/interactor/RemoveMangaHistory.kt | aniyomiorg | 358,887,741 | false | {"Kotlin": 4957619} | package eu.kanade.domain.history.manga.interactor
import eu.kanade.domain.history.manga.model.MangaHistoryWithRelations
import eu.kanade.domain.history.manga.repository.MangaHistoryRepository
class RemoveMangaHistory(
private val repository: MangaHistoryRepository,
) {
suspend fun awaitAll(): Boolean {
return repository.deleteAllMangaHistory()
}
suspend fun await(history: MangaHistoryWithRelations) {
repository.resetMangaHistory(history.id)
}
suspend fun await(mangaId: Long) {
repository.resetHistoryByMangaId(mangaId)
}
}
| 180 | Kotlin | 315 | 4,992 | 823099f775ef608b7c11f096da1f50762dab82df | 585 | aniyomi | Apache License 2.0 |
idea/testData/editor/quickDoc/OnMethodUsageWithSee.kt | staltz | 51,743,245 | false | null | /**
* @see C
* @see D
*/
fun testMethod() {
}
class C {
}
class D {
}
fun test() {
<caret>testMethod(1, "value")
}
//INFO: <b>internal</b> <b>fun</b> testMethod(): Unit <i>defined in</i> root package<br/>
//INFO: <DD><DL><DT><b>See Also:</b><DD><a href="psi_element://C"><code>C</code></a>, <a href="psi_element://D"><code>D</code></a></DD></DL></DD>
| 0 | null | 0 | 1 | f713adc96e9adeacb1373fc170a5ece1bf2fc1a2 | 363 | kotlin | Apache License 2.0 |
src/main/kotlin/codes/jakob/tstse/example/common/Query.kt | The-Self-Taught-Software-Engineer | 392,776,173 | false | null | package codes.jakob.tstse.example.common
import kotlin.reflect.KProperty1
abstract class Query<T>(protected val value: T) {
abstract fun isEqualTo(value: T): Query<T>
abstract fun <T> contains(element: T): Query<T>
companion object {
@JvmName("where")
fun <T, V> where(property: KProperty1<T, V>): Query<V> {
TODO("Not yet implemented")
}
@JvmName("whereCollection")
fun <T, V> where(property: KProperty1<T, Collection<V>>): Query<V> {
TODO("Not yet implemented")
}
}
}
| 0 | Kotlin | 2 | 3 | 2c90b9420c7e8188b3eee84838579bb6930efb68 | 563 | Examples | MIT License |
mpdomain/src/main/java/com/jpp/mpdomain/repository/PersonRepository.kt | perettijuan | 156,444,935 | false | null | package com.jpp.mpdomain.repository
import com.jpp.mpdomain.Person
import com.jpp.mpdomain.SupportedLanguage
/**
* Repository definition to retrieve a [Person] whenever is possible.
*/
interface PersonRepository {
/**
* Retrieves the person that is identified by [personId].
*/
suspend fun getPerson(personId: Double, language: SupportedLanguage): Person?
/**
* Flushes out any stored data.
*/
suspend fun flushPersonData()
}
| 9 | Kotlin | 7 | 46 | 7921806027d5a9b805782ed8c1cad447444f476b | 467 | moviespreview | Apache License 2.0 |
app/src/main/java/com/vcl/wallet/MainActivity.kt | velocitycareerlabs | 525,006,413 | false | null | /**
* Copyright 2022 Velocity Career Labs inc.
* SPDX-License-Identifier: Apache-2.0
*/
package com.vcl.wallet
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import androidx.core.view.isVisible
import com.vcl.wallet.databinding.ActivityMainBinding
import io.velocitycareerlabs.api.VCLEnvironment
import io.velocitycareerlabs.api.VCLProvider
import io.velocitycareerlabs.api.entities.*
import org.json.JSONObject
class MainActivity : AppCompatActivity() {
private val TAG = MainActivity::class.simpleName
private lateinit var binding: ActivityMainBinding
private val environment = VCLEnvironment.DEV
private val vcl = VCLProvider.vclInstance()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityMainBinding.inflate(layoutInflater)
setContentView(binding.root)
binding.disclosingCredentials.setOnClickListener {
getPresentationRequest()
}
binding.receivingCredentialsByDeeplink.setOnClickListener {
getCredentialManifestByDeepLink()
}
binding.receivingCredentialsByServices.setOnClickListener {
getOrganizationsThenCredentialManifestByService()
}
binding.selfReportingCredentials.setOnClickListener {
getCredentialTypesUIFormSchema()
}
binding.refreshCredentials.setOnClickListener {
refreshCredentials()
}
binding.getVerifiedProfile.setOnClickListener {
getVerifiedProfile()
}
binding.verifyJwt.setOnClickListener {
verifyJwt()
}
binding.generateSignedJwt.setOnClickListener {
generateSignedJwt()
}
binding.generateDidJwk.setOnClickListener {
generateDidJwk()
}
vcl.initialize(
initializationDescriptor = VCLInitializationDescriptor(
context = this.applicationContext,
environment = environment
),
successHandler = {
Log.d(TAG, "VCL initialization succeed!")
showControls()
},
errorHandler = { error ->
logError("VCL initialization failed:", error)
showError()
}
)
}
private fun showControls() {
binding.loadingIndicator.isVisible = false
binding.controlsView.isVisible = true
}
private fun showError() {
binding.loadingIndicator.isVisible = false
binding.errorView.isVisible = true
}
private fun getPresentationRequest() {
val deepLink =
if (environment == VCLEnvironment.DEV)
VCLDeepLink(Constants.PresentationRequestDeepLinkStrDev)
else
VCLDeepLink(Constants.PresentationRequestDeepLinkStrStaging)
vcl.getPresentationRequest(
presentationRequestDescriptor = VCLPresentationRequestDescriptor(
deepLink = deepLink,
pushDelegate = VCLPushDelegate(
pushUrl = "pushUrl",
pushToken = "pushToken"
)
),
{ presentationRequest ->
Log.d(TAG, "VCL Presentation request received: ${presentationRequest.jwt.payload}")
// Log.d(TAG, "VCL Presentation request received")
submitPresentation(presentationRequest)
},
{ error ->
logError("VCL Presentation request failed:", error)
})
}
private fun submitPresentation(presentationRequest: VCLPresentationRequest) {
val presentationSubmission = VCLPresentationSubmission(
presentationRequest = presentationRequest,
verifiableCredentials = Constants.PresentationSelectionsList
)
submitPresentation(presentationSubmission)
}
private fun submitPresentation(presentationSubmission: VCLPresentationSubmission) {
vcl.submitPresentation(presentationSubmission,
{ presentationSubmissionResult ->
Log.d(TAG, "VCL Presentation submission result: $presentationSubmissionResult")
vcl.getExchangeProgress(
VCLExchangeDescriptor(
presentationSubmission,
presentationSubmissionResult
),
{ exchange ->
Log.d(TAG, "VCL Presentation exchange progress $exchange")
},
{ error ->
logError("VCL Presentation exchange progress failed:", error)
})
},
{ error ->
logError("VCL Presentation submission failed:", error)
})
}
private fun getOrganizationsThenCredentialManifestByService() {
val organizationDescriptor =
if (environment == VCLEnvironment.DEV)
Constants.OrganizationsSearchDescriptorByDidDev
else
Constants.OrganizationsSearchDescriptorByDidStaging
vcl.searchForOrganizations(organizationDescriptor,
{ organizations ->
Log.d(TAG, "VCL Organizations received: $organizations")
// Log.d(TAG, "VCL Organizations received")
// choosing services[0] for testing purposes
organizations.all.getOrNull(0)?.serviceCredentialAgentIssuers?.getOrNull(0)?.let { service ->
getCredentialManifestByService(service)
} ?: Log.e(TAG, "VCL Organizations error, issuing service not found")
},
{ error ->
logError("VCL Organizations search failed:", error)
}
)
}
private fun refreshCredentials() {
val service = VCLService(
JSONObject(
Constants.IssuingServiceJsonStr)
)
val credentialManifestDescriptorRefresh =
VCLCredentialManifestDescriptorRefresh(
service = service,
credentialIds = Constants.CredentialIds
)
vcl.getCredentialManifest(credentialManifestDescriptorRefresh,
{ credentialManifest ->
Log.d(TAG, "VCL Credentials refreshed, credential manifest: ${credentialManifest.jwt.payload}")
},
{ error ->
logError("VCL Refresh Credentials failed:", error)
})
}
private fun getCredentialManifestByService(serviceCredentialAgentIssuer: VCLServiceCredentialAgentIssuer) {
val credentialManifestDescriptorByOrganization =
VCLCredentialManifestDescriptorByService(
service = serviceCredentialAgentIssuer,
issuingType = VCLIssuingType.Career,
credentialTypes = serviceCredentialAgentIssuer.credentialTypes // Can come from any where
)
vcl.getCredentialManifest(credentialManifestDescriptorByOrganization,
{ credentialManifest ->
Log.d(TAG, "VCL Credential Manifest received: ${credentialManifest.jwt.payload}")
// Log.d(TAG, "VCL Credential Manifest received")
generateOffers(credentialManifest)
},
{ error ->
logError("VCL Credential Manifest failed:", error)
})
}
private fun getCredentialManifestByDeepLink() {
val deepLink =
if (environment == VCLEnvironment.DEV)
VCLDeepLink(Constants.CredentialManifestDeepLinkStrDev)
else
VCLDeepLink(Constants.CredentialManifestDeepLinkStrStaging)
val credentialManifestDescriptorByDeepLink =
VCLCredentialManifestDescriptorByDeepLink(
deepLink = deepLink,
// issuingType = VCLIssuingType.Career
)
vcl.getCredentialManifest(credentialManifestDescriptorByDeepLink,
{ credentialManifest ->
Log.d(TAG, "VCL Credential Manifest received: ${credentialManifest.jwt.payload}")
// Log.d(TAG, "VCL Credential Manifest received")
generateOffers(credentialManifest)
},
{ error ->
logError("VCL Credential Manifest failed:", error)
})
}
private fun generateOffers(credentialManifest: VCLCredentialManifest) {
val generateOffersDescriptor = VCLGenerateOffersDescriptor(
credentialManifest = credentialManifest,
types = Constants.CredentialTypes,
identificationVerifiableCredentials = Constants.IdentificationList
)
vcl.generateOffers(
generateOffersDescriptor = generateOffersDescriptor,
{ offers ->
Log.d(TAG, "VCL Generated Offers: ${offers.all}")
Log.d(TAG, "VCL Generated Offers Response Code: ${offers.responseCode}")
Log.d(TAG, "VCL Generated Offers Token: ${offers.token}")
// Check offers invoked after the push notification is notified the app that offers are ready:
checkForOffers(
credentialManifest = credentialManifest,
generateOffersDescriptor = generateOffersDescriptor,
token = offers.token
)
},
{ error ->
logError("VCL failed to Generate Offers:", error)
}
)
}
private fun checkForOffers(
credentialManifest: VCLCredentialManifest,
generateOffersDescriptor: VCLGenerateOffersDescriptor,
token: VCLToken
) {
vcl.checkForOffers(
generateOffersDescriptor = generateOffersDescriptor,
token = token,
{ offers ->
Log.d(TAG, "VCL Checked Offers: ${offers.all}")
Log.d(TAG, "VCL Checked Offers Response Code: ${offers.responseCode}")
Log.d(TAG, "VCL Checked Offers Token: ${offers.token}")
if (offers.responseCode == 200) {
finalizeOffers(
credentialManifest = credentialManifest,
offers = offers
)
}
},
{ error ->
logError("VCL failed to Check Offers:", error)
}
)
}
private fun finalizeOffers(
credentialManifest: VCLCredentialManifest,
offers: VCLOffers
) {
val approvedRejectedOfferIds = Utils.getApprovedRejectedOfferIdsMock(offers)
val finalizeOffersDescriptor = VCLFinalizeOffersDescriptor(
credentialManifest = credentialManifest,
approvedOfferIds = approvedRejectedOfferIds.first,
rejectedOfferIds = approvedRejectedOfferIds.second
)
vcl.finalizeOffers(
finalizeOffersDescriptor = finalizeOffersDescriptor,
token = offers.token,
{ verifiableCredentials ->
Log.d(TAG, "VCL finalized Offers: ${verifiableCredentials.all.map { it.payload }}")
// Log.d(TAG, "VCL finalized Offers")
},
{ error ->
logError("VCL failed to finalize Offers:", error)
}
)
}
private fun getCredentialTypesUIFormSchema() {
vcl.getCredentialTypesUIFormSchema(
VCLCredentialTypesUIFormSchemaDescriptor(
Constants.ResidentPermitV10,
VCLCountries.CA
),
{ credentialTypesUIFormSchema ->
Log.d(TAG, "VCL received Credential Types UI Form Schema: $credentialTypesUIFormSchema")
},
{ error ->
logError("VCL failed to get Credential Types UI Form Schema:", error)
}
)
}
private fun getVerifiedProfile() {
vcl.getVerifiedProfile(Constants.VerifiedProfileDescriptor,
{ verifiedProfile ->
Log.d(TAG, "VCL Verified Profile: $verifiedProfile")
},
{ error ->
logError("VCL Verified Profile failed:", error)
}
)
}
private fun verifyJwt() {
vcl.verifyJwt(
Constants.SomeJwt, Constants.SomeJwkPublic, { isVerified ->
Log.d(TAG, "VCL JWT verified: $isVerified")
},
{ error ->
logError("VCL JWT verification failed:", error)
}
)
}
private fun generateSignedJwt() {
vcl.generateSignedJwt(
VCLJwtDescriptor(Constants.SomeJson, "iss123", "jti123"),
{ jwt ->
Log.d(TAG, "VCL JWT generated: ${jwt.signedJwt.serialize()}")
},
{ error ->
logError("VCL JWT generation failed:", error)
}
)
}
private fun generateDidJwk() {
vcl.generateDidJwk(
{ didJwk ->
Log.d(TAG, "VCL DID:JWK generated: ${didJwk.value}")
},
{ error ->
logError("VCL DID:JWK generation failed:", error)
}
)
}
private fun logError(message: String = "", error: VCLError) {
Log.e(TAG, "${message}: ${error.toJsonObject()}")
}
}
| 6 | null | 0 | 2 | 160e938b2a3a676800e65aabec95c7badffbb4a6 | 13,403 | WalletAndroid | Apache License 2.0 |
core/src/test/kotlin/net/corda/core/serialization/CommandsSerializationTests.kt | desertfund | 166,518,885 | true | {"Kotlin": 8029221, "Java": 319210, "Python": 36499, "CSS": 23489, "Shell": 19343, "Gherkin": 3162, "Groovy": 2129, "Dockerfile": 1905, "Batchfile": 1777, "PowerShell": 660, "Makefile": 569} | package net.corda.core.serialization
import net.corda.finance.contracts.CommercialPaper
import net.corda.finance.contracts.asset.Cash
import net.corda.testing.SerializationEnvironmentRule
import org.junit.Rule
import org.junit.Test
import kotlin.test.assertEquals
class CommandsSerializationTests {
@Rule
@JvmField
val testSerialization = SerializationEnvironmentRule()
@Test
fun `test cash move serialization`() {
val command = Cash.Commands.Move(CommercialPaper::class.java)
val copiedCommand = command.serialize().deserialize()
assertEquals(command, copiedCommand)
}
} | 0 | Kotlin | 0 | 1 | c36bea3af521be69f7702d7b7abbbfac0258de1f | 623 | corda | Apache License 2.0 |
src/test/kotlin/edu/umontreal/kotlingrad/calculus/TestGradient.kt | shafiahmed | 287,769,250 | true | {"Kotlin": 242199} | package edu.umontreal.kotlingrad.calculus
import edu.umontreal.kotlingrad.numerical.DoublePrecision
import edu.umontreal.kotlingrad.shouldBeAbout
import io.kotlintest.properties.assertAll
import io.kotlintest.specs.StringSpec
@Suppress("NonAsciiCharacters", "LocalVariableName")
class TestGradient: StringSpec({
with(DoublePrecision) {
val ε = 1E-15
val x = Var("x")
val y = Var("y")
val z = y * (sin(x * y) - x)
val `∇z` = z.grad()
"test ∇z" {
NumericalGenerator.assertAll { ẋ, ẏ ->
val vals = mapOf(x to ẋ, y to ẏ)
val `∂z∕∂x` = y * (cos(x * y) * y - 1)
val `∂z∕∂y` = sin(x * y) - x + y * cos(x * y) * x
`∇z`[x]!!(vals) shouldBeAbout `∂z∕∂x`(vals)
`∇z`[y]!!(vals) shouldBeAbout `∂z∕∂y`(vals)
}
}
}
}) | 1 | null | 0 | 0 | bf66daf62431182761e5b0097d88bd6102319413 | 792 | kotlingrad | Apache License 2.0 |
app/src/main/java/developersancho/mvvm/ui/databindingtest/DViewModel.kt | developersancho | 204,070,386 | false | null | package developersancho.mvvm.ui.databindingtest
import com.developersancho.manager.IDataManager
import developersancho.mvvm.base.BaseViewModel
import developersancho.mvvm.base.IBasePresenter
class DViewModel(dataManager: IDataManager) : BaseViewModel<IBasePresenter>(dataManager) | 0 | Kotlin | 9 | 43 | 88f182e5a6dc266957c59ff20338b53a974d9fac | 281 | CleanArchitectureMVVM | Apache License 2.0 |
web/src/main/kotlin/top/bettercode/summer/web/support/gb2260/GB2260Controller.kt | top-bettercode | 387,652,015 | false | null | package top.bettercode.summer.web.support.gb2260
import com.fasterxml.jackson.annotation.JsonView
import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RequestParam
import top.bettercode.summer.logging.annotation.RequestLogging
import top.bettercode.summer.security.authorize.Anonymous
import top.bettercode.summer.web.BaseController
@ConditionalOnWebApplication
@Anonymous
@RequestMapping(value = ["/divisions"], name = "行政区划")
class GB2260Controller : BaseController() {
@RequestLogging(includeResponseBody = false)
@JsonView(AllDivisionView::class)
@GetMapping(value = ["/list"], name = "列表（全）")
fun list(@RequestParam(defaultValue = "false") vnode: Boolean = false): Any {
val divisions = if (vnode)
GB2260.provinces
else {
val provinces = GB2260.provinces.map {
if (it.municipality) {
Division(
code = it.code,
name = it.name,
level = it.level,
municipality = true,
vnode = it.vnode,
parentNames = it.parentNames,
children = it.children[0].children
)
} else {
it
}
}
provinces
}
return ok(divisions)
}
@RequestLogging(includeResponseBody = false)
@JsonView(DivisionView::class)
@GetMapping(value = ["/select"], name = "列表")
fun select(code: String?, @RequestParam(defaultValue = "false") vnode: Boolean = false): Any {
val divisions = if (code.isNullOrBlank()) {
GB2260.provinces
} else {
val code1 = String.format("%-6s", code).replace(" ", "0")
val division = GB2260.getDivision(code1)
val children = division.children
if (!vnode && division.municipality) {
children[0].children
} else {
children
}
}
return ok(divisions)
}
} | 0 | null | 0 | 2 | 3e4c089f6a05cf0dcd658e1e792f0f3edcbff649 | 2,279 | summer | Apache License 2.0 |
SecureCamera/src/main/java/io/github/toyota32k/secureCamera/CameraActivity.kt | toyota-m2k | 594,937,009 | false | null | package io.github.toyota32k.secureCamera
import android.Manifest
import android.annotation.SuppressLint
import android.content.Context
import android.content.pm.ActivityInfo
import android.content.res.Configuration
import android.graphics.Bitmap
import android.os.Bundle
import android.view.KeyEvent
import android.view.WindowManager
import androidx.activity.viewModels
import androidx.camera.core.Camera
import androidx.camera.core.ExperimentalZeroShutterLag
import androidx.camera.view.PreviewView
import androidx.lifecycle.ViewModel
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.viewModelScope
import io.github.toyota32k.binder.Binder
import io.github.toyota32k.binder.BoolConvert
import io.github.toyota32k.binder.VisibilityBinding
import io.github.toyota32k.binder.command.LiteUnitCommand
import io.github.toyota32k.binder.command.bindCommand
import io.github.toyota32k.binder.headlessNonnullBinding
import io.github.toyota32k.binder.visibilityBinding
import io.github.toyota32k.dialog.broker.UtMultiPermissionsBroker
import io.github.toyota32k.dialog.task.UtImmortalTaskManager
import io.github.toyota32k.dialog.task.UtMortalActivity
import io.github.toyota32k.lib.camera.TcCamera
import io.github.toyota32k.lib.camera.TcCameraManager
import io.github.toyota32k.lib.camera.TcCameraManipulator
import io.github.toyota32k.lib.camera.TcLib
import io.github.toyota32k.lib.camera.gesture.ICameraGestureOwner
import io.github.toyota32k.lib.camera.usecase.ITcUseCase
import io.github.toyota32k.lib.camera.usecase.TcImageCapture
import io.github.toyota32k.lib.camera.usecase.TcVideoCapture
import io.github.toyota32k.secureCamera.ScDef.PHOTO_EXTENSION
import io.github.toyota32k.secureCamera.ScDef.PHOTO_PREFIX
import io.github.toyota32k.secureCamera.ScDef.VIDEO_EXTENSION
import io.github.toyota32k.secureCamera.ScDef.VIDEO_PREFIX
import io.github.toyota32k.secureCamera.databinding.ActivityCameraBinding
import io.github.toyota32k.secureCamera.db.MetaDB
import io.github.toyota32k.secureCamera.settings.Settings
import io.github.toyota32k.secureCamera.utils.Direction
import io.github.toyota32k.secureCamera.utils.hideActionBar
import io.github.toyota32k.secureCamera.utils.hideStatusBar
import io.github.toyota32k.utils.UtLog
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.launch
import java.io.File
class CameraActivity : UtMortalActivity(), ICameraGestureOwner {
override val logger = UtLog("CAMERA")
class CameraViewModel : ViewModel() {
val frontCameraSelected = MutableStateFlow(true)
val showControlPanel = MutableStateFlow(true)
// val fullControlPanel = MutableStateFlow(true)
val recordingState = MutableStateFlow(TcVideoCapture.RecordingState.NONE)
// val expandPanelCommand = LiteCommand<Boolean> { fullControlPanel.value = it }
// val showPanelCommand = LiteCommand<Boolean> { showControlPanel.value = it }
@ExperimentalZeroShutterLag // region UseCases
val imageCapture by lazy { TcImageCapture.Builder().zeroLag().build() }
// val videoCapture by lazy { TcVideoCapture.Builder().useFixedPoolExecutor().build() }
// 一旦カメラに接続（bindToLifecycle）した VideoCapture は、unbindAll()しても、別のカメラに接続し直すと例外が出る。
// > IllegalStateException: Surface was requested when the Recorder had been initialized with state IDLING
// これを回避するため、カメラを切り替える場合は、TcVideoCapture を作り直すことにする。
// つまり、録画中にカメラを切り替える操作は（システム的に）不可能。
private var mVideoCapture: TcVideoCapture? = null
val videoCapture: TcVideoCapture
get() = mVideoCapture ?: TcVideoCapture.Builder().useFixedPoolExecutor().recordingStateFlow(recordingState).build().apply { mVideoCapture = this }
/**
* VideoCaptureの再作成を予約。
*/
fun resetVideoCaptureOnFlipCamera() {
mVideoCapture?.dispose()
mVideoCapture = null
}
override fun onCleared() {
super.onCleared()
videoCapture.dispose()
}
val pictureTakingStatus = MutableStateFlow<Boolean>(false)
val takePictureCommand = LiteUnitCommand()
fun takePicture(logger:UtLog) {
viewModelScope.launch {
pictureTakingStatus.value = true
try {
val bitmap = imageCapture.takePicture() ?: return@launch
val file = newImageFile()
file.outputStream().use {
bitmap.compress(Bitmap.CompressFormat.JPEG, 100, it)
it.flush()
}
MetaDB.register(file.name, 0,0)
} catch(e:Throwable) {
logger.error(e)
} finally {
delay(200)
pictureTakingStatus.value = false
}
}
}
fun newVideoFile(): File {
return File(TcLib.applicationContext.filesDir, ITcUseCase.defaultFileName(VIDEO_PREFIX, VIDEO_EXTENSION))
}
fun newImageFile(): File {
return File(TcLib.applicationContext.filesDir, ITcUseCase.defaultFileName(PHOTO_PREFIX, PHOTO_EXTENSION))
}
@SuppressLint("MissingPermission")
val takeVideoCommand = LiteUnitCommand {
when (recordingState.value) {
TcVideoCapture.RecordingState.NONE -> {
val file = newVideoFile()
videoCapture.takeVideoInFile(file) {
CoroutineScope(Dispatchers.IO).launch {
MetaDB.register(file.name, 0, 0)
}
}
}
TcVideoCapture.RecordingState.STARTED -> videoCapture.pause()
TcVideoCapture.RecordingState.PAUSING -> videoCapture.resume()
}
}
val finalizeVideoCommand = LiteUnitCommand {
if(recordingState.value != TcVideoCapture.RecordingState.NONE) {
videoCapture.stop()
}
}
}
private val permissionsBroker = UtMultiPermissionsBroker(this)
private val cameraManager: TcCameraManager by lazy { TcCameraManager.initialize(this) }
private var currentCamera: TcCamera? = null
private val binder = Binder()
private val viewModel by viewModels<CameraViewModel>()
private val cameraManipulator : TcCameraManipulator by lazy { TcCameraManipulator(this, TcCameraManipulator.FocusActionBy.LongTap, rapidTap = false) }
private lateinit var controls: ActivityCameraBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
controls = ActivityCameraBinding.inflate(layoutInflater)
setContentView(controls.root)
requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
hideActionBar()
hideStatusBar()
// controls.previewView.apply {
// isClickable = true
// isLongClickable = true
// }
binder
.owner(this)
.headlessNonnullBinding(viewModel.frontCameraSelected) { changeCamera(it) }
.visibilityBinding(controls.controlPanel, viewModel.showControlPanel)
.visibilityBinding(controls.miniRecIndicator, combine(viewModel.showControlPanel,viewModel.recordingState) {panel,rec-> !panel && rec==TcVideoCapture.RecordingState.STARTED}, boolConvert = BoolConvert.Straight, VisibilityBinding.HiddenMode.HideByGone)
.visibilityBinding(controls.miniShutterIndicator, viewModel.pictureTakingStatus, boolConvert = BoolConvert.Straight, hiddenMode = VisibilityBinding.HiddenMode.HideByGone)
.visibilityBinding(controls.flipCameraButton, viewModel.recordingState.map { it==TcVideoCapture.RecordingState.NONE}, boolConvert = BoolConvert.Straight, hiddenMode = VisibilityBinding.HiddenMode.HideByGone)
// .multiVisibilityBinding(arrayOf(controls.flipCameraButton, controls.closeButton), combine(viewModel.fullControlPanel,viewModel.recordingState) {full,state-> full && state== TcVideoCapture.RecordingState.NONE}, hiddenMode = VisibilityBinding.HiddenMode.HideByGone)
// .visibilityBinding(controls.expandButton, combine(viewModel.fullControlPanel,viewModel.recordingState) {full, state-> !full && state== TcVideoCapture.RecordingState.NONE}, BoolConvert.Straight, VisibilityBinding.HiddenMode.HideByGone)
// .visibilityBinding(controls.collapseButton, combine(viewModel.fullControlPanel,viewModel.recordingState) {full, state-> full && state== TcVideoCapture.RecordingState.NONE}, BoolConvert.Straight, VisibilityBinding.HiddenMode.HideByGone)
.visibilityBinding(controls.videoRecButton, viewModel.recordingState.map { it!= TcVideoCapture.RecordingState.STARTED}, BoolConvert.Straight, VisibilityBinding.HiddenMode.HideByGone)
.visibilityBinding(controls.videoPauseButton, viewModel.recordingState.map { it== TcVideoCapture.RecordingState.STARTED}, BoolConvert.Straight, VisibilityBinding.HiddenMode.HideByGone)
.visibilityBinding(controls.videoStopButton, viewModel.recordingState.map { it!= TcVideoCapture.RecordingState.NONE}, BoolConvert.Straight, VisibilityBinding.HiddenMode.HideByGone)
// .bindCommand(viewModel.expandPanelCommand, controls.expandButton, true)
// .bindCommand(viewModel.expandPanelCommand, controls.collapseButton, false)
// .bindCommand(viewModel.showPanelCommand, controls.closeButton, false)
.bindCommand(viewModel.takePictureCommand, controls.photoButton) { takePicture() }
.bindCommand(viewModel.takeVideoCommand, controls.videoRecButton, controls.videoPauseButton)
.bindCommand(viewModel.finalizeVideoCommand, controls.videoStopButton)
.bindCommand(LiteUnitCommand(this::toggleCamera), controls.flipCameraButton)
// cameraGestureManager = CameraGestureManager.Builder()
// .enableFocusGesture()
// .enableZoomGesture()
// .longTapCustomAction {
// viewModel.showControlPanel.value = !viewModel.showControlPanel.value
// true
// }
// .build(this)
window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
gestureScope.launch {
if(permissionsBroker.Request()
.add(Manifest.permission.CAMERA)
.add(Manifest.permission.RECORD_AUDIO)
.execute()) {
cameraManager.prepare()
val me = UtImmortalTaskManager.mortalInstanceSource.getOwner().asActivity() as? CameraActivity ?: return@launch
me.startCamera(viewModel.frontCameraSelected.value)
}
}
}
override fun onConfigurationChanged(newConfig: Configuration) {
super.onConfigurationChanged(newConfig)
logger.debug("${newConfig.orientation}")
}
override fun onDestroy() {
super.onDestroy()
window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
if(isFinishing) {
cameraManager.unbind()
}
}
// private fun hideActionBar() {
// supportActionBar?.hide()
// }
// private fun hideStatusBar() {
// WindowCompat.setDecorFitsSystemWindows(window, false)
// WindowInsetsControllerCompat(window, controls.root).let { controller ->
// controller.hide(WindowInsetsCompat.Type.systemBars())
// controller.systemBarsBehavior = WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE
// }
// }
private fun toggleCamera() {
val current = currentCamera?.frontCamera ?: return
changeCamera(!current)
}
private fun changeCamera(front:Boolean) {
val camera = currentCamera ?: return
if(camera.frontCamera!=front) {
lifecycleScope.launch {
startCamera(front)
}
}
}
private fun startCamera(front: Boolean) {
try {
viewModel.resetVideoCaptureOnFlipCamera()
val modes = cameraManager.cameraExtensions.capabilitiesOf(front).fold(StringBuffer()) { acc, mode->
if(acc.isNotEmpty()) {
acc.append(",")
}
acc.append(mode.toString())
acc
}.insert(0,"capabilities = ").toString()
logger.debug(modes)
@ExperimentalZeroShutterLag // region UseCases
currentCamera = cameraManager.CameraBuilder()
.frontCamera(front)
.standardPreview(previewView)
.imageCapture(viewModel.imageCapture)
.videoCapture(viewModel.videoCapture)
.build(this)
.apply {
cameraManipulator.attachCamera(this@CameraActivity, camera, controls.previewView) {
onFlickVertical {
viewModel.showControlPanel.value = it.direction == Direction.Start
}
onFlickHorizontal {
viewModel.showControlPanel.value = it.direction == Direction.Start
}
// onDoubleTap {
// if(!viewModel.showControlPanel.value) {
// viewModel.takeVideoCommand.invoke()
// }
// }
onTap {
if(!viewModel.showControlPanel.value) {
when(Settings.Camera.tapAction) {
Settings.Camera.TAP_PHOTO -> {
takePicture(it.x, it.y)
}
Settings.Camera.TAP_VIDEO -> {
viewModel.takeVideoCommand.invoke()
}
else -> {}
}
}
}
}
}
} catch (e: Throwable) {
logger.error(e)
}
}
private fun takePicture(x:Float=-1f, y:Float=-1f) {
if(x<0||y<0) {
// 画面中央に表示
controls.miniShutterIndicator.x = controls.root.width/2f - controls.miniShutterIndicator.width / 2f
controls.miniShutterIndicator.y = controls.root.height/2f - controls.miniShutterIndicator.height / 2f
} else {
// 指定位置に表示
controls.miniShutterIndicator.x = x - controls.miniShutterIndicator.width / 2
controls.miniShutterIndicator.y = y - controls.miniShutterIndicator.height / 2
}
viewModel.takePicture(logger)
}
override fun handleKeyEvent(keyCode: Int, event: KeyEvent?): Boolean {
if(keyCode==KeyEvent.KEYCODE_VOLUME_UP && event?.action==KeyEvent.ACTION_DOWN) {
takePicture()
return true
}
return super.handleKeyEvent(keyCode, event)
}
// ICameraGestureOwner
override val context: Context
get() = this
override val gestureScope: CoroutineScope
get() = this.lifecycleScope
override val previewView: PreviewView
get() = controls.previewView
override val camera: Camera?
get() = currentCamera?.camera
} | 4 | Kotlin | 0 | 0 | ef438ddc4f0736c37a32f7861648b19d95054af9 | 15,645 | android-camera | Apache License 2.0 |
navigation/runtime/src/androidTest/java/androidx/navigation/ActivityNavigatorTest.kt | adamfit | 148,326,589 | false | {"Java": 30446439, "Kotlin": 2649136, "Python": 43821, "ANTLR": 20090, "Shell": 18933, "HTML": 514, "IDL": 308} | /*
* Copyright 2018 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.navigation
import android.app.Activity
import android.content.ComponentName
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import androidx.test.filters.MediumTest
import androidx.test.rule.ActivityTestRule
import androidx.test.runner.AndroidJUnit4
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertNotNull
import org.junit.Assert.assertTrue
import org.junit.Assert.fail
import org.junit.Before
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
import org.mockito.ArgumentMatchers.any
import org.mockito.Mockito.mock
import org.mockito.Mockito.spy
import org.mockito.Mockito.timeout
import org.mockito.Mockito.verify
import org.mockito.Mockito.verifyNoMoreInteractions
@MediumTest
@RunWith(AndroidJUnit4::class)
class ActivityNavigatorTest {
companion object {
const val TARGET_ID = 1
const val TARGET_ACTION = "test_action"
val TARGET_DATA: Uri = Uri.parse("http://www.example.com")
const val TARGET_ARGUMENT_NAME = "test"
const val TARGET_DATA_PATTERN = "http://www.example.com/{$TARGET_ARGUMENT_NAME}"
const val TARGET_ARGUMENT_VALUE = "data_pattern"
}
@get:Rule
val activityRule = ActivityTestRule(ActivityNavigatorActivity::class.java)
private lateinit var activityNavigator: ActivityNavigator
private lateinit var onNavigatedListener: Navigator.OnNavigatorNavigatedListener
@Before
fun setup() {
activityNavigator = ActivityNavigator(activityRule.activity)
onNavigatedListener = mock(Navigator.OnNavigatorNavigatedListener::class.java)
activityNavigator.addOnNavigatorNavigatedListener(onNavigatedListener)
TargetActivity.instances = spy(ArrayList())
}
@After
fun cleanup() {
TargetActivity.instances.forEach { activity ->
activity.finish()
}
}
@Test
fun navigate() {
val targetDestination = activityNavigator.createDestination().apply {
id = TARGET_ID
setComponentName(ComponentName(activityRule.activity, TargetActivity::class.java))
}
activityNavigator.navigate(targetDestination, null, null)
verify(onNavigatedListener).onNavigatorNavigated(activityNavigator, TARGET_ID,
Navigator.BACK_STACK_UNCHANGED)
verifyNoMoreInteractions(onNavigatedListener)
val targetActivity = waitForActivity()
val intent = targetActivity.intent
assertNotNull(intent)
assertEquals("Intent should not include FLAG_ACTIVITY_NEW_TASK",
0, intent.flags and Intent.FLAG_ACTIVITY_NEW_TASK)
}
@Test
fun navigateFromNonActivityContext() {
// Create using the applicationContext
val activityNavigator = ActivityNavigator(activityRule.activity.applicationContext)
val onNavigatedListener = mock(Navigator.OnNavigatorNavigatedListener::class.java)
activityNavigator.addOnNavigatorNavigatedListener(onNavigatedListener)
val targetDestination = activityNavigator.createDestination().apply {
id = TARGET_ID
setComponentName(ComponentName(activityRule.activity, TargetActivity::class.java))
}
activityNavigator.navigate(targetDestination, null, null)
verify(onNavigatedListener).onNavigatorNavigated(activityNavigator, TARGET_ID,
Navigator.BACK_STACK_UNCHANGED)
verifyNoMoreInteractions(onNavigatedListener)
val targetActivity = waitForActivity()
val intent = targetActivity.intent
assertNotNull(intent)
assertEquals("Intent should include FLAG_ACTIVITY_NEW_TASK",
Intent.FLAG_ACTIVITY_NEW_TASK, intent.flags and Intent.FLAG_ACTIVITY_NEW_TASK)
}
@Test
fun navigateSingleTop() {
val targetDestination = activityNavigator.createDestination().apply {
id = TARGET_ID
setComponentName(ComponentName(activityRule.activity, TargetActivity::class.java))
}
activityNavigator.navigate(targetDestination, null, navOptions {
launchSingleTop = true
})
verify(onNavigatedListener).onNavigatorNavigated(activityNavigator, TARGET_ID,
Navigator.BACK_STACK_UNCHANGED)
verifyNoMoreInteractions(onNavigatedListener)
val targetActivity = waitForActivity()
val intent = targetActivity.intent
assertNotNull(intent)
assertEquals("Intent should include FLAG_ACTIVITY_SINGLE_TOP",
Intent.FLAG_ACTIVITY_SINGLE_TOP, intent.flags and Intent.FLAG_ACTIVITY_SINGLE_TOP)
}
@Test
fun navigateWithArgs() {
val targetDestination = activityNavigator.createDestination().apply {
id = TARGET_ID
setComponentName(ComponentName(activityRule.activity, TargetActivity::class.java))
}
val args = Bundle().apply {
putString(TARGET_ARGUMENT_NAME, TARGET_ARGUMENT_VALUE)
}
activityNavigator.navigate(targetDestination, args, null)
verify(onNavigatedListener).onNavigatorNavigated(activityNavigator, TARGET_ID,
Navigator.BACK_STACK_UNCHANGED)
verifyNoMoreInteractions(onNavigatedListener)
val targetActivity = waitForActivity()
val intent = targetActivity.intent
assertNotNull(intent)
assertEquals("Intent should have its arguments in its extras",
TARGET_ARGUMENT_VALUE, intent.getStringExtra(TARGET_ARGUMENT_NAME))
}
@Test
fun navigateAction() {
val targetDestination = activityNavigator.createDestination().apply {
id = TARGET_ID
action = TARGET_ACTION
setComponentName(ComponentName(activityRule.activity, TargetActivity::class.java))
}
activityNavigator.navigate(targetDestination, null, null)
verify(onNavigatedListener).onNavigatorNavigated(activityNavigator, TARGET_ID,
Navigator.BACK_STACK_UNCHANGED)
verifyNoMoreInteractions(onNavigatedListener)
val targetActivity = waitForActivity()
val intent = targetActivity.intent
assertNotNull(intent)
assertEquals("Intent should have action set",
TARGET_ACTION, intent.action)
}
@Test
fun navigateData() {
val targetDestination = activityNavigator.createDestination().apply {
id = TARGET_ID
data = TARGET_DATA
setComponentName(ComponentName(activityRule.activity, TargetActivity::class.java))
}
activityNavigator.navigate(targetDestination, null, null)
verify(onNavigatedListener).onNavigatorNavigated(activityNavigator, TARGET_ID,
Navigator.BACK_STACK_UNCHANGED)
verifyNoMoreInteractions(onNavigatedListener)
val targetActivity = waitForActivity()
val intent = targetActivity.intent
assertNotNull(intent)
assertEquals("Intent should have data set",
TARGET_DATA, intent.data)
}
@Test
fun navigateDataPattern() {
val targetDestination = activityNavigator.createDestination().apply {
id = TARGET_ID
dataPattern = TARGET_DATA_PATTERN
setComponentName(ComponentName(activityRule.activity, TargetActivity::class.java))
}
val args = Bundle().apply {
putString(TARGET_ARGUMENT_NAME, TARGET_ARGUMENT_VALUE)
}
activityNavigator.navigate(targetDestination, args, null)
verify(onNavigatedListener).onNavigatorNavigated(activityNavigator, TARGET_ID,
Navigator.BACK_STACK_UNCHANGED)
verifyNoMoreInteractions(onNavigatedListener)
val targetActivity = waitForActivity()
val intent = targetActivity.intent
assertNotNull(intent)
assertEquals("Intent should have data set with argument filled in",
TARGET_DATA_PATTERN.replace("{$TARGET_ARGUMENT_NAME}", TARGET_ARGUMENT_VALUE),
intent.data?.toString())
assertEquals("Intent should have its arguments in its extras",
TARGET_ARGUMENT_VALUE, intent.getStringExtra(TARGET_ARGUMENT_NAME))
}
@Test
fun navigateDataPatternMissingArgument() {
val targetDestination = activityNavigator.createDestination().apply {
id = TARGET_ID
dataPattern = TARGET_DATA_PATTERN
setComponentName(ComponentName(activityRule.activity, TargetActivity::class.java))
}
try {
val args = Bundle()
activityNavigator.navigate(targetDestination, args, null)
fail("navigate() should fail if required arguments are not included")
} catch (e: IllegalArgumentException) {
// Expected
}
verifyNoMoreInteractions(onNavigatedListener)
}
private fun waitForActivity(): TargetActivity {
verify(TargetActivity.instances, timeout(3000)).add(any())
verifyNoMoreInteractions(TargetActivity.instances)
val targetActivity: ArrayList<TargetActivity> = ArrayList()
activityRule.runOnUiThread {
targetActivity.addAll(TargetActivity.instances)
}
assertTrue("Only expected a single TargetActivity", targetActivity.size == 1)
return targetActivity[0]
}
}
class ActivityNavigatorActivity : Activity()
class TargetActivity : Activity() {
companion object {
var instances: ArrayList<TargetActivity> = spy(ArrayList())
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
instances.add(this)
}
}
| 1 | Java | 1 | 2 | 9e6a7849696fce73bb81005a81b78410bfebc6d6 | 10,314 | platform_frameworks_support | Apache License 2.0 |
app/src/main/java/com/example/caniwatchitapplication/data/api/WatchmodeApi.kt | bitasuperactive | 798,400,133 | false | {"Kotlin": 82135} | package com.example.caniwatchitapplication.data.api
import com.example.caniwatchitapplication.data.model.QuotaResponse
import com.example.caniwatchitapplication.data.model.StreamingSourcesResponse
import com.example.caniwatchitapplication.data.model.TitleDetailsResponse
import com.example.caniwatchitapplication.data.model.TitlesIdsResponse
import com.example.caniwatchitapplication.util.Constants.Companion.API_KEY
import com.example.caniwatchitapplication.util.Constants.Companion.STREAMING_SOURCE_REGIONS
import com.example.caniwatchitapplication.util.Constants.Companion.STREAMING_SOURCE_TYPES
import com.example.caniwatchitapplication.util.Constants.Companion.TITLE_LANGUAGE
import com.example.caniwatchitapplication.util.Constants.Companion.TITLE_TYPES
import retrofit2.Response
import retrofit2.http.GET
import retrofit2.http.Path
import retrofit2.http.Query
/**
* Watchmode - [API Docs](https://api.watchmode.com/docs/)
*/
interface WatchmodeApi
{
/**
* Recupera el número de peticiones realizadas y las contratadas por mes para una clave
* específica.
*
* _No consume creditos adicionales de la api._
*/
@GET("/v1/status/")
suspend fun getQuota(
@Query("apiKey")
apiKey: String = API_KEY
): Response<QuotaResponse>
/**
* Recupera todos los servicios de streaming disponibles para unos tipos de contenido y unas
* regiones específicas.
*/
@GET("/v1/sources/")
suspend fun getAllStreamingSources(
@Query("apiKey")
apiKey: String = API_KEY,
@Query("types")
types: String = STREAMING_SOURCE_TYPES,
@Query("regions")
regions: String = STREAMING_SOURCE_REGIONS
): Response<StreamingSourcesResponse>
/**
* Recupera los identificadores correspondientes a los títulos coincidentes con un valor
* de búsqueda.
*
* @param searchValue Nombre original de los títulos a recuperar
*/
@GET("/v1/search/")
suspend fun searchForTitles(
@Query("search_value")
searchValue: String,
@Query("apiKey")
apiKey: String = API_KEY,
@Query("search_field")
searchField: String = "name",
@Query("types")
types: String = TITLE_TYPES
): Response<TitlesIdsResponse>
/**
* Recupera los detalles de un título específico mediante su identificador único.
*
* @param titleId Identificador único del título a recuperar
*/
@GET("/v1/title/{title_id}/details/")
suspend fun getTitleDetails(
@Path("title_id")
titleId: String,
@Query("apiKey")
apiKey: String = API_KEY,
@Query("append_to_response")
appendToResponse: String = "sources",
@Query("language")
language: String = TITLE_LANGUAGE
): Response<TitleDetailsResponse>
} | 0 | Kotlin | 0 | 0 | eaa30bf6639663d9a5c5d055783b5dbbe72e1622 | 2,841 | CanIWatchIt | MIT License |
presentation/src/main/kotlin/team/dahaeng/android/activity/tasking/TaskingViewModel.kt | dahaeng | 443,726,900 | false | {"Kotlin": 109864} | /*
* Dahaeng © 2022 Ji Sungbin, 210202. all rights reserved.
* Dahaeng license is under the MIT.
*
* [TaskingViewModel.kt] created by 210202
*
* Please see: https://github.com/dahaeng/dahaeng-android/blob/main/LICENSE.
*/
package team.dahaeng.android.activity.tasking
import dagger.hilt.android.lifecycle.HiltViewModel
import team.dahaeng.android.activity.base.BaseViewModel
import javax.inject.Inject
@HiltViewModel
class TaskingViewModel @Inject constructor() : BaseViewModel()
| 3 | Kotlin | 0 | 14 | 8c61b8b5ae5f82dfde97f60795fc65b9abb1aceb | 490 | dahaeng-android | MIT License |
app/src/main/kotlin/com/absinthe/libchecker/BaseActivity.kt | acidsweet | 380,161,938 | true | {"Kotlin": 585068, "Java": 115999, "Roff": 42612, "AIDL": 637, "HTML": 125} | package com.absinthe.libchecker
import android.os.Bundle
import android.view.ViewGroup
import com.absinthe.libchecker.extensions.paddingTopCompat
import com.absinthe.libchecker.extensions.setSystemPadding
import com.absinthe.libchecker.ui.app.AppActivity
import com.absinthe.libraries.utils.manager.SystemBarManager
import com.absinthe.libraries.utils.utils.UiUtils
import com.absinthe.libraries.utils.utils.UiUtils.setSystemBarStyle
abstract class BaseActivity : AppActivity() {
protected var root: ViewGroup? = null
protected var isPaddingToolbar = false
protected abstract fun setViewBinding(): ViewGroup
protected fun setRootPadding() {
root?.setSystemPadding()
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setViewBindingImpl(setViewBinding())
window.decorView.post { setSystemBarStyle(window) }
if (isPaddingToolbar) {
root?.paddingTopCompat = UiUtils.getStatusBarHeight()
}
SystemBarManager.measureSystemBar(window)
}
private fun setViewBindingImpl(root: ViewGroup) {
this.root = root
setContentView(root)
}
} | 1 | null | 0 | 1 | 4218fcbcd55de2255ebc8c37d859b53417da3ddc | 1,190 | LibChecker | Apache License 2.0 |
vuesaxicons/src/commonMain/kotlin/moe/tlaster/icons/vuesax/vuesaxicons/broken/Ticketexpired.kt | Tlaster | 560,394,734 | false | {"Kotlin": 25133302} | package moe.tlaster.icons.vuesax.vuesaxicons.broken
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.PathFillType
import androidx.compose.ui.graphics.PathFillType.Companion.NonZero
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.graphics.StrokeCap
import androidx.compose.ui.graphics.StrokeCap.Companion.Round
import androidx.compose.ui.graphics.StrokeJoin
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.graphics.vector.ImageVector.Builder
import androidx.compose.ui.graphics.vector.path
import androidx.compose.ui.unit.dp
import moe.tlaster.icons.vuesax.vuesaxicons.BrokenGroup
public val BrokenGroup.Ticketexpired: ImageVector
get() {
if (_ticketexpired != null) {
return _ticketexpired!!
}
_ticketexpired = Builder(name = "Ticketexpired", defaultWidth = 24.0.dp, defaultHeight =
24.0.dp, viewportWidth = 24.0f, viewportHeight = 24.0f).apply {
path(fill = SolidColor(Color(0x00000000)), stroke = SolidColor(Color(0xFF292D32)),
strokeLineWidth = 1.5f, strokeLineCap = Round, strokeLineJoin =
StrokeJoin.Companion.Round, strokeLineMiter = 4.0f, pathFillType = NonZero) {
moveTo(22.0f, 10.75f)
verticalLineTo(9.83f)
curveTo(22.0f, 6.13f, 21.08f, 5.21f, 17.38f, 5.21f)
horizontalLineTo(11.0f)
verticalLineTo(12.0f)
}
path(fill = SolidColor(Color(0x00000000)), stroke = SolidColor(Color(0xFF292D32)),
strokeLineWidth = 1.5f, strokeLineCap = Round, strokeLineJoin =
StrokeJoin.Companion.Round, strokeLineMiter = 4.0f, pathFillType = NonZero) {
moveTo(10.9102f, 20.0001f)
horizontalLineTo(17.3802f)
curveTo(21.0802f, 20.0001f, 22.0002f, 19.0801f, 22.0002f, 15.3801f)
curveTo(20.7202f, 15.3801f, 19.6902f, 14.3401f, 19.6902f, 13.0701f)
}
path(fill = SolidColor(Color(0x00000000)), stroke = SolidColor(Color(0xFF292D32)),
strokeLineWidth = 1.5f, strokeLineCap = Round, strokeLineJoin =
StrokeJoin.Companion.Round, strokeLineMiter = 4.0f, pathFillType = NonZero) {
moveTo(10.9994f, 16.9999f)
verticalLineTo(19.9999f)
horizontalLineTo(8.2294f)
curveTo(6.7494f, 19.9999f, 5.8794f, 18.9899f, 4.9194f, 16.6699f)
lineTo(4.7394f, 16.2199f)
curveTo(5.9494f, 15.7399f, 6.5394f, 14.3399f, 6.0294f, 13.1299f)
curveTo(5.5394f, 11.9199f, 4.1494f, 11.3399f, 2.9294f, 11.8399f)
lineTo(2.7594f, 11.4099f)
curveTo(1.3194f, 7.8899f, 1.8194f, 6.6599f, 5.3394f, 5.2099f)
lineTo(7.9794f, 4.1299f)
lineTo(10.9994f, 11.4499f)
verticalLineTo(13.9999f)
}
path(fill = SolidColor(Color(0x00000000)), stroke = SolidColor(Color(0xFF292D32)),
strokeLineWidth = 1.5f, strokeLineCap = Round, strokeLineJoin =
StrokeJoin.Companion.Round, strokeLineMiter = 4.0f, pathFillType = NonZero) {
moveTo(8.17f, 20.0f)
horizontalLineTo(8.0f)
}
}
.build()
return _ticketexpired!!
}
private var _ticketexpired: ImageVector? = null
| 0 | Kotlin | 0 | 2 | b8a8231e6637c2008f675ae76a3423b82ee53950 | 3,480 | VuesaxIcons | MIT License |
src/main/kotlin/rtw/server/command/CommandRtw.kt | r4v3n6101 | 169,856,173 | false | null | package rtw.server.command
import net.minecraft.command.CommandBase
import net.minecraft.command.ICommandSender
import rtw.common.ModMain
import rtw.common.util.MOON_PHASES_NAMES
import rtw.common.util.getDaysSinceNewMoon
import rtw.common.util.getMoonPhaseNumber
import rtw.common.util.getSolarHourAngle
import java.time.LocalDateTime
import java.time.format.DateTimeFormatter
class CommandRtw : CommandBase() {
override fun getCommandName() = "rtw"
override fun getRequiredPermissionLevel() = 2
override fun getCommandUsage(sender: ICommandSender) = "return date & time"
override fun processCommand(sender: ICommandSender, args: Array<String>) {
val rtwData = ModMain.proxy.rtwData
val ldt = LocalDateTime.now(rtwData.zoneOffset)
val daysSinceNewMoon = getDaysSinceNewMoon(ldt.toLocalDate())
val moonPhase = getMoonPhaseNumber(daysSinceNewMoon)
func_152373_a(sender, this, ldt.format(DateTimeFormatter.ISO_DATE_TIME))
func_152373_a(
sender, this,
"Solar hour angle (deg): ${getSolarHourAngle(rtwData.longitude.toDouble())}"
)
func_152373_a(sender, this, "Moon phase: ${MOON_PHASES_NAMES[moonPhase]}")
func_152373_a(sender, this, rtwData.toString())
}
} | 0 | Kotlin | 0 | 1 | d45cc666a455235e92d5b163bccee8c46222939e | 1,285 | rtw | Do What The F*ck You Want To Public License |
src/docs/guide/howto/deploy_webjars/example.kt | http4k | 86,003,479 | false | null | package guide.howto.deploy_webjars
import org.http4k.core.Method.GET
import org.http4k.core.Request
import org.http4k.core.Response
import org.http4k.core.Status.Companion.OK
import org.http4k.routing.bind
import org.http4k.routing.routes
import org.http4k.routing.webJars
import org.http4k.server.SunHttp
import org.http4k.server.asServer
fun main() {
// mix the WebJars routing into your app...
val app = routes(
"/myGreatRoute" bind GET to { req: Request -> Response(OK) },
webJars()
)
app.asServer(SunHttp(8080)).start()
// then browse to: http://localhost:8080/webjars/swagger-ui/4.11.1/index.html
}
| 34 | null | 248 | 2,610 | 4e8d2f278a7c146bcf24380fb596590b430a66ad | 645 | http4k | Apache License 2.0 |
app/src/test/java/com/igorwojda/list/capitalizeFirst/CapitalizeFirst.kt | tmdroid | 289,856,448 | true | {"Kotlin": 199701} | package com.igorwojda.list.capitalizeFirst
import org.amshove.kluent.shouldEqual
import org.junit.Test
private fun capitalizeFirst(list: List<String>): List<String> {
if (list.isEmpty()) return emptyList()
val list = list.toMutableList()
val first = list.removeFirst().capitalize()
return listOf(first) + capitalizeFirst(list)
}
class CapitalizeFirstTest {
@Test
fun `capitalize list with one string`() {
capitalizeFirst(listOf("igor")) shouldEqual listOf("Igor")
}
@Test
fun `capitalize list with two strings`() {
capitalizeFirst(listOf("igor", "wojda")) shouldEqual listOf("Igor", "Wojda")
}
@Test
fun `capitalize empty list`() {
capitalizeFirst(listOf("")) shouldEqual listOf("")
}
@Test
fun `capitalize list with sentence`() {
capitalizeFirst(listOf("what a", "beautiful", "morning")) shouldEqual listOf(
"What a",
"Beautiful",
"Morning"
)
}
}
| 0 | Kotlin | 0 | 0 | 66c932f020914c21d75d3ad5cffce6f7f63ee6ed | 995 | kotlin-coding-puzzle | MIT License |
gi/src/commonMain/kotlin/org/anime_game_servers/multi_proto/gi/data/team/skill/ProudSkillExtraLevelNotify.kt | Anime-Game-Servers | 642,871,918 | false | {"Kotlin": 1651536} | package org.anime_game_servers.multi_proto.gi.data.team.skill
import org.anime_game_servers.core.base.Version.GI_CB2
import org.anime_game_servers.core.base.annotations.AddedIn
import org.anime_game_servers.core.base.annotations.proto.CommandType.*
import org.anime_game_servers.core.base.annotations.proto.ProtoCommand
@AddedIn(GI_CB2)
@ProtoCommand(NOTIFY)
internal interface ProudSkillExtraLevelNotify {
var avatarGuid: Long
var extraLevel: Int
var talentIndex: Int
var talentType: Int
}
| 0 | Kotlin | 2 | 6 | 7639afe4f546aa5bbd9b4afc9c06c17f9547c588 | 509 | anime-game-multi-proto | MIT License |
app/src/main/java/com/memad/moviesmix/ui/main/viewer/worker/DownloadCompletedReceiver.kt | Mohamed-Emad126 | 438,245,160 | false | {"Kotlin": 191086, "Makefile": 158} | package com.memad.moviesmix.ui.main.viewer.worker
import android.content.BroadcastReceiver
import android.content.Context
import android.content.Intent
import android.widget.Toast
import dagger.hilt.android.AndroidEntryPoint
@AndroidEntryPoint
class DownloadCompletedReceiver : BroadcastReceiver() {
override fun onReceive(context: Context?, intent: Intent?) {
if (intent?.action == "android.intent.action.DOWNLOAD_COMPLETE") {
Toast.makeText(context, "Download Completed", Toast.LENGTH_SHORT).show()
}
}
} | 0 | Kotlin | 8 | 45 | a0d5aea7c91db0eef3a847918998a84e79a335ba | 545 | MoviesMix | MIT License |
src/main/kotlin/com/bridgecrew/ui/CheckovSettingsPanel.kt | bridgecrewio | 644,310,885 | false | {"Kotlin": 300288, "Java": 2400} | package com.bridgecrew.ui
import com.bridgecrew.settings.PrismaSettingsConfigurable
import com.bridgecrew.utils.createGridRowCol
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.options.ShowSettingsUtil
import com.intellij.openapi.project.Project
import com.intellij.uiDesigner.core.GridConstraints
import com.intellij.uiDesigner.core.GridLayoutManager
import com.intellij.util.ui.JBUI
import javax.swing.JButton
import javax.swing.JLabel
import javax.swing.JPanel
class CheckovSettingsPanel(project: Project): JPanel() {
init {
layout = GridLayoutManager(3, 1, JBUI.emptyInsets(), -1, -1)
add(JLabel("Prisma Cloud Plugin would scan your infrastructure as code files."), createGridRowCol(0,0, GridConstraints.ANCHOR_CENTER))
add(JLabel("Please configure a valid Prisma token in order to use this Plugin"), createGridRowCol(1,0, GridConstraints.ANCHOR_CENTER))
val settingsButton = JButton("Open Settings")
settingsButton.addActionListener {
ApplicationManager.getApplication().invokeLater {
ShowSettingsUtil.getInstance().showSettingsDialog(project, PrismaSettingsConfigurable::class.java)
}
}
add(settingsButton, createGridRowCol(2,0, GridConstraints.ANCHOR_CENTER))
}
}
| 11 | Kotlin | 0 | 1 | ea65b22fceb2d9bb387a815141ea8e7b4c2830c9 | 1,322 | prisma-cloud-jetbrains-ide | Apache License 2.0 |
font-awesome/src/commonMain/kotlin/compose/icons/fontawesomeicons/solid/PlaneDeparture.kt | DevSrSouza | 311,134,756 | false | null | package compose.icons.fontawesomeicons.solid
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.PathFillType.Companion.NonZero
import androidx.compose.ui.graphics.SolidColor
import androidx.compose.ui.graphics.StrokeCap.Companion.Butt
import androidx.compose.ui.graphics.StrokeJoin.Companion.Miter
import androidx.compose.ui.graphics.vector.ImageVector
import androidx.compose.ui.graphics.vector.ImageVector.Builder
import androidx.compose.ui.graphics.vector.path
import androidx.compose.ui.unit.dp
import compose.icons.fontawesomeicons.SolidGroup
public val SolidGroup.PlaneDeparture: ImageVector
get() {
if (_planeDeparture != null) {
return _planeDeparture!!
}
_planeDeparture = Builder(name = "PlaneDeparture", defaultWidth = 640.0.dp, defaultHeight =
512.0.dp, viewportWidth = 640.0f, viewportHeight = 512.0f).apply {
path(fill = SolidColor(Color(0xFF000000)), stroke = null, strokeLineWidth = 0.0f,
strokeLineCap = Butt, strokeLineJoin = Miter, strokeLineMiter = 4.0f,
pathFillType = NonZero) {
moveTo(624.0f, 448.0f)
horizontalLineTo(16.0f)
curveToRelative(-8.84f, 0.0f, -16.0f, 7.16f, -16.0f, 16.0f)
verticalLineToRelative(32.0f)
curveToRelative(0.0f, 8.84f, 7.16f, 16.0f, 16.0f, 16.0f)
horizontalLineToRelative(608.0f)
curveToRelative(8.84f, 0.0f, 16.0f, -7.16f, 16.0f, -16.0f)
verticalLineToRelative(-32.0f)
curveToRelative(0.0f, -8.84f, -7.16f, -16.0f, -16.0f, -16.0f)
close()
moveTo(80.55f, 341.27f)
curveToRelative(6.28f, 6.84f, 15.1f, 10.72f, 24.33f, 10.71f)
lineToRelative(130.54f, -0.18f)
arcToRelative(65.62f, 65.62f, 0.0f, false, false, 29.64f, -7.12f)
lineToRelative(290.96f, -147.65f)
curveToRelative(26.74f, -13.57f, 50.71f, -32.94f, 67.02f, -58.31f)
curveToRelative(18.31f, -28.48f, 20.3f, -49.09f, 13.07f, -63.65f)
curveToRelative(-7.21f, -14.57f, -24.74f, -25.27f, -58.25f, -27.45f)
curveToRelative(-29.85f, -1.94f, -59.54f, 5.92f, -86.28f, 19.48f)
lineToRelative(-98.51f, 49.99f)
lineToRelative(-218.7f, -82.06f)
arcToRelative(17.8f, 17.8f, 0.0f, false, false, -18.0f, -1.11f)
lineTo(90.62f, 67.29f)
curveToRelative(-10.67f, 5.41f, -13.25f, 19.65f, -5.17f, 28.53f)
lineToRelative(156.22f, 98.1f)
lineToRelative(-103.21f, 52.38f)
lineToRelative(-72.35f, -36.47f)
arcToRelative(17.8f, 17.8f, 0.0f, false, false, -16.07f, 0.02f)
lineTo(9.91f, 230.22f)
curveToRelative(-10.44f, 5.3f, -13.19f, 19.12f, -5.57f, 28.08f)
lineToRelative(76.21f, 82.97f)
close()
}
}
.build()
return _planeDeparture!!
}
private var _planeDeparture: ImageVector? = null
| 17 | null | 25 | 571 | a660e5f3033e3222e3553f5a6e888b7054aed8cd | 3,156 | compose-icons | MIT License |
Object-Oriented Programming/Nested Classes/Exercise 3/src/Task.kt | marchdz | 633,862,396 | false | null | // NestedClasses/NestedEx3.kt
package nestedClassesExercise3
import atomictest.*
abstract class Cleanable(val id: String) {
open val parts: List<Cleanable> = listOf()
fun clean(): String {
val text = "$id clean"
if (parts.isEmpty()) return text
return "${parts.joinToString(
" ", "(", ")",
transform = Cleanable::clean)} $text\n"
}
}
class Shelf
class Closet
class Toilet
class Sink
class Bathroom
class Bedroom
class House : Cleanable("House") {
/*TODO*/
}
fun main() {
House().clean() eq """
(((Shelf clean Shelf clean) Closet clean
(Toilet clean Sink clean) Bathroom clean
) Master Bedroom clean
((Shelf clean Shelf clean) Closet clean
(Toilet clean Sink clean) Bathroom clean
) Guest Bedroom clean
) House clean
"""
} | 0 | Kotlin | 0 | 0 | 0246a342b54600ceb6ac38ecb4498d16a7e86e8e | 783 | atomic-kotlin-exercises | MIT License |
app/src/main/java/com/example/httpsender/vm/MultiTaskFlowDownloader.kt | liujingxing | 167,158,553 | false | null | package com.example.httpsender.vm
import android.annotation.SuppressLint
import androidx.lifecycle.MutableLiveData
import com.example.httpsender.Tip
import com.example.httpsender.entity.DownloadTask
import com.example.httpsender.utils.Preferences
import okhttp3.internal.http2.StreamResetException
import okio.ByteString.Companion.encodeUtf8
import rxhttp.RxHttpPlugins
import rxhttp.wrapper.param.RxHttp
import java.io.File
import java.util.*
/**
* User: ljx
* Date: 2020/7/12
* Time: 18:00
*/
object MultiTaskDownloader {
const val IDLE = 0 //未开始，闲置状态
const val WAITING = 1 //等待中状态
const val DOWNLOADING = 2 //下载中
const val PAUSED = 3 //已暂停
const val COMPLETED = 4 //已完成
const val FAIL = 5 //下载失败
const val CANCEL = 6 //取消状态，等待时被取消
private const val MAX_TASK_COUNT = 3 //最大并发数
@JvmStatic
val liveTask = MutableLiveData<DownloadTask>() //用于刷新UI
@JvmStatic
val allTask = ArrayList<DownloadTask>() //所有下载任务
private val waitTask = LinkedList<DownloadTask>() //等待下载的任务
private val downloadingTask = LinkedList<DownloadTask>() //下载中的任务
//记录每个文件的总大小，key为文件url
private val lengthMap = HashMap<String, Long>()
@JvmStatic
fun addTasks(tasks: ArrayList<DownloadTask>) {
val allTaskList = allTask
tasks.forEach {
if (!allTaskList.contains(it)) {
val md5Key = it.url.encodeUtf8().md5().hex()
val length = Preferences.getValue(md5Key, -1L)
if (length != -1L) {
it.totalSize = length
it.currentSize = File(it.localPath).length()
it.progress = it.currentSize * 1.0f / it.totalSize
lengthMap[it.url] = length
if (it.currentSize > 0) {
it.state = PAUSED
}
if (it.totalSize == it.currentSize) {
//如果当前size等于总size，则任务文件下载完成，注意: 这个判断不是100%准确，最好能对文件做md5校验
it.state = COMPLETED
}
}
allTaskList.add(it)
}
}
}
//开始下载所有任务
@JvmStatic
fun startAllDownloadTask() {
val allTaskList = allTask
allTaskList.forEach {
if (it.state != COMPLETED && it.state != DOWNLOADING) {
download(it)
}
}
}
@SuppressLint("CheckResult")
@JvmStatic
fun download(task: DownloadTask) {
if (downloadingTask.size >= MAX_TASK_COUNT) {
//超过最大下载数，添加进等待队列
task.state = WAITING
updateTask(task)
waitTask.offer(task)
return
}
task.state = DOWNLOADING
updateTask(task)
downloadingTask.add(task)
//如果想使用Await或Flow下载，更改以下代码即可
RxHttp.get(task.url)
.tag(task.url) //记录tag，手动取消下载时用到
.toDownloadObservable(task.localPath, true)
.onMainProgress {
//下载进度回调,0-100，仅在进度有更新时才会回调
task.speed = it.speed
task.remainingTime = it.calculateRemainingTime()
task.progress = it.fraction //当前进度 [0.0, 1.0]
task.currentSize = it.currentSize //当前已下载的字节大小
task.totalSize = it.totalSize //要下载的总字节大小
updateTask(task)
val key = task.url
val length = lengthMap[key]
if (length != task.totalSize) {
//服务器返回的文件总大小与本地的不一致，则更新
lengthMap[key] = task.totalSize
saveTotalSize(lengthMap)
}
}
.doFinally {
updateTask(task)
//不管任务成功还是失败，如果还有在等待的任务，都开启下一个任务
downloadingTask.remove(task)
waitTask.poll()?.let { download(it) }
}
.subscribe({
Tip.show("下载完成")
task.state = COMPLETED
}, {
//手动取消下载时，会收到StreamResetException异常，不做任何处理
if (it !is StreamResetException){
Tip.show("下载失败")
task.state = FAIL
}
})
}
private fun saveTotalSize(map: HashMap<String, Long>) {
val editor = Preferences.getEditor()
for ((key, value) in map) {
val md5Key = key.encodeUtf8().md5().hex()
editor.putLong(md5Key, value)
}
editor.commit()
}
//关闭所有任务
@JvmStatic
fun cancelAllTask() {
var iterator = waitTask.iterator()
while (iterator.hasNext()) {
val task = iterator.next()
task.state = CANCEL
iterator.remove()
updateTask(task)
}
iterator = downloadingTask.iterator()
while (iterator.hasNext()) {
val task = iterator.next()
iterator.remove()
RxHttpPlugins.cancelAll(task.url)
task.state = CANCEL
updateTask(task)
}
}
//等待中->取消下载
@JvmStatic
fun removeWaitTask(task: DownloadTask) {
waitTask.remove(task)
task.state = CANCEL
updateTask(task)
}
//暂停下载
@JvmStatic
fun pauseTask(task: DownloadTask) {
//根据tag取消下载
RxHttpPlugins.cancelAll(task.url)
task.state = PAUSED
task.speed = 0
task.remainingTime = -1
updateTask(task)
}
@JvmStatic
fun haveTaskExecuting(): Boolean {
return waitTask.size > 0 || downloadingTask.size > 0
}
//发送通知，更新UI
private fun updateTask(task: DownloadTask) {
liveTask.value = task
}
} | 9 | null | 459 | 3,748 | 47e075dbf05e1a89e3f2a722bb61ba633d523ac3 | 5,743 | rxhttp | Apache License 2.0 |
push-message-provider-hpk/src/test/kotlin/ru/touchin/push/message/provider/hpk/services/HmsHpkClientServiceTest.kt | TouchInstinct | 256,563,788 | false | null | package ru.touchin.push.message.provider.hpk.services
import com.nhaarman.mockitokotlin2.any
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import org.mockito.Mockito
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.boot.test.mock.mockito.MockBean
import ru.touchin.push.message.provider.dto.PushMessageNotification
import ru.touchin.push.message.provider.dto.request.PushTokenMessage
import ru.touchin.push.message.provider.exceptions.InvalidPushTokenException
import ru.touchin.push.message.provider.exceptions.PushMessageProviderException
import ru.touchin.push.message.provider.hpk.clients.hms_hpk.HmsHpkWebClient
import ru.touchin.push.message.provider.hpk.clients.hms.enums.HmsResponseCode
import ru.touchin.push.message.provider.hpk.clients.hms_hpk.responses.HmsHpkResponse
@SpringBootTest
class HmsHpkClientServiceTest {
@MockBean
lateinit var hmsHpkWebClient: HmsHpkWebClient
@MockBean
lateinit var hmsOauthClientService: HmsOauthClientService
@Autowired
lateinit var hmsHpkClientService: HmsHpkClientService
@Test
fun send_throwsInvalidPushTokenExceptionForKnownErrors() {
Mockito.`when`(
hmsOauthClientService.getAccessToken()
).then { "accessToken" }
Mockito.`when`(
hmsHpkWebClient.messagesSend(any())
).then {
HmsHpkResponse(
code = HmsResponseCode.INVALID_TOKEN.value.toString(),
msg = "0",
requestId = "requestId"
)
}
val pushTokenMessage = PushTokenMessage(
token = "token",
pushMessageNotification = PushMessageNotification(
title = "title",
description = "description",
imageUrl = null
),
data = emptyMap()
)
Assertions.assertThrows(
InvalidPushTokenException::class.java
) { hmsHpkClientService.send(pushTokenMessage) }
}
@Test
fun send_throwsPushMessageProviderExceptionOnOtherExceptions() {
Mockito.`when`(
hmsOauthClientService.getAccessToken()
).then { "accessToken" }
Mockito.`when`(
hmsHpkWebClient.messagesSend(any())
).then {
HmsHpkResponse(
code = HmsResponseCode.OAUTH_TOKEN_EXPIRED.value.toString(),
msg = "0",
requestId = "requestId"
)
}
val pushTokenMessage = PushTokenMessage(
token = "token",
pushMessageNotification = PushMessageNotification(
title = "title",
description = "description",
imageUrl = null
),
data = emptyMap()
)
Assertions.assertThrows(
PushMessageProviderException::class.java
) { hmsHpkClientService.send(pushTokenMessage) }
}
@Test
fun send_passesSuccess() {
Mockito.`when`(
hmsOauthClientService.getAccessToken()
).then { "accessToken" }
Mockito.`when`(
hmsHpkWebClient.messagesSend(any())
).then {
HmsHpkResponse(
code = HmsResponseCode.SUCCESS.value.toString(),
msg = "0",
requestId = "requestId"
)
}
val pushTokenMessage = PushTokenMessage(
token = "token",
pushMessageNotification = PushMessageNotification(
title = "title",
description = "description",
imageUrl = null
),
data = emptyMap()
)
Assertions.assertDoesNotThrow {
hmsHpkClientService.send(pushTokenMessage)
}
}
}
| 1 | Kotlin | 1 | 3 | c8ed908656dc5d28b77961131188ef5b65a98e0d | 3,867 | Backend-common | Apache License 2.0 |
core/src/main/java/com/codeart/filmskuy/core/ui/CatalogueListAdapter.kt | WahyuSeptiadi | 326,314,895 | false | {"Java": 200862, "Kotlin": 90625} | package com.codeart.filmskuy.core.ui
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.recyclerview.widget.RecyclerView
import com.bumptech.glide.Glide
import com.codeart.filmskuy.core.R
import com.codeart.filmskuy.core.databinding.ItemListCatalogueBinding
import com.codeart.filmskuy.core.domain.model.CatalogueModel
import com.codeart.filmskuy.core.utils.IMAGE_URL_BASE_PATH
import java.util.*
/**
* Created by wahyu_septiadi on 17, January 2021.
* Visit My GitHub --> https://github.com/WahyuSeptiadi
*/
class CatalogueListAdapter : RecyclerView.Adapter<CatalogueListAdapter.ListViewHolder>() {
private var listData = ArrayList<CatalogueModel>()
var onItemClick: ((CatalogueModel) -> Unit)? = null
fun setData(newListData: List<CatalogueModel>?) {
if (newListData == null) return
listData.clear()
listData.addAll(newListData)
notifyDataSetChanged()
}
inner class ListViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
private val binding = ItemListCatalogueBinding.bind(itemView)
fun bind(data: CatalogueModel) {
with(binding) {
val imageSize = itemView.context.getString(R.string.size_url_poster_main)
val urlImage = "$IMAGE_URL_BASE_PATH$imageSize${data.posterPath}"
Glide.with(itemView.context)
.load(urlImage)
.placeholder(R.drawable.loadings)
.error(R.drawable.img_notfound)
.into(imageFilm)
if (data.voteAverage.toString().length > 3) {
ratingFilm.text = data.voteAverage.toString().substring(0, 2)
} else {
ratingFilm.text = data.voteAverage.toString()
}
titleFilm.text = data.entry
if (data.date != "") {
yearFilm.text = data.date?.substring(0, 4)
}
}
}
init {
binding.root.setOnClickListener {
onItemClick?.invoke(listData[adapterPosition])
}
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) =
ListViewHolder(
LayoutInflater.from(parent.context).inflate(R.layout.item_list_catalogue, parent, false)
)
override fun onBindViewHolder(holder: ListViewHolder, position: Int) {
val data = listData[position]
holder.bind(data)
}
override fun getItemCount() = listData.size
} | 1 | null | 1 | 1 | a3931acf762ebec00bdf1783142920ef16dc1471 | 2,591 | AndroidExpert | MIT License |
shared/src/commonMain/kotlin/home/presentation/HomeScreen.kt | AndreVero | 735,628,501 | false | {"Kotlin": 75143, "Swift": 669, "Shell": 228} | @file:OptIn(ExperimentalResourceApi::class)
package home.presentation
import androidx.compose.animation.AnimatedVisibility
import androidx.compose.animation.core.Spring
import androidx.compose.animation.core.VisibilityThreshold
import androidx.compose.animation.core.spring
import androidx.compose.animation.fadeIn
import androidx.compose.animation.fadeOut
import androidx.compose.animation.slideIn
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.layout.width
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.Icon
import androidx.compose.material.IconButton
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Text
import androidx.compose.material.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.IntOffset
import androidx.compose.ui.unit.dp
import cafe.adriel.voyager.core.screen.Screen
import cafe.adriel.voyager.navigator.LocalNavigator
import cafe.adriel.voyager.navigator.currentOrThrow
import home.presentation.components.tasks.TasksComponent
import kotlinx.coroutines.flow.collectLatest
import org.jetbrains.compose.resources.ExperimentalResourceApi
import org.jetbrains.compose.resources.painterResource
import org.koin.compose.koinInject
import tasks.presentation.TasksScreen
import utils.LocalSnackbarHostState
object HomeScreen : Screen {
@Composable
override fun Content() {
val viewModel = koinInject<HomeViewModel>()
val localSnackbarHost = LocalSnackbarHostState.current
val navigator = LocalNavigator.currentOrThrow
LaunchedEffect(true) {
viewModel.uiEvent.collectLatest { event ->
when (event) {
is HomeUiEvent.ShowError -> localSnackbarHost.showSnackbar(event.message)
}
}
}
Column(
modifier = Modifier.fillMaxSize().background(Color.Black),
horizontalAlignment = Alignment.CenterHorizontally,
verticalArrangement = Arrangement.Top
) {
TopAppBar(
title = {
Text(
text = "Easy Task",
style = MaterialTheme.typography.h3,
color = Color.White
)
},
backgroundColor = Color.Transparent,
actions = {
IconButton(
modifier = Modifier.clip(CircleShape).background(Color.White),
onClick = {}
) {
Icon(
painter = painterResource("icon_chart.xml"),
tint = Color.Black,
contentDescription = "Statistic"
)
}
},
modifier = Modifier.padding(top = 16.dp)
)
Spacer(modifier = Modifier.height(100.dp))
Box(modifier = Modifier.fillMaxSize()) {
Column(modifier = Modifier.align(Alignment.TopCenter)) {
AnimatedVisibility(
!viewModel.state.isLoading,
enter = fadeIn(),
exit = fadeOut(),
) {
Box {
TasksComponent(
modifier = Modifier.size(420.dp).align(Alignment.Center),
goals = viewModel.state.goals,
onTaskClick = {}
)
Text(
text = "Choose Your Destiny",
color = Color.White,
textAlign = TextAlign.Center,
style = MaterialTheme.typography.h4,
modifier = Modifier.align(Alignment.Center).width(100.dp)
)
}
}
}
Column(modifier = Modifier.align(Alignment.BottomCenter)) {
AnimatedVisibility(
visible = !viewModel.state.isLoading,
enter = slideIn(
initialOffset = { IntOffset(0, it.height) },
animationSpec = spring(
stiffness = Spring.StiffnessMediumLow,
visibilityThreshold = IntOffset.VisibilityThreshold
)
)
) {
Box(modifier = Modifier
.clip(RoundedCornerShape(topStart = 40.dp, topEnd = 40.dp))
.fillMaxWidth()
.height(120.dp)
.background(Color.White)
.clickable { navigator.push(TasksScreen) }
) {
Text(
text = "Tasks for Today",
style = MaterialTheme.typography.h3,
modifier = Modifier.align(Alignment.Center)
)
}
}
}
}
}
}
} | 0 | Kotlin | 0 | 0 | bb53d3d0bf3059105fbd16a5bfb033b62c51568d | 6,224 | EasyTask | Apache License 2.0 |
components/settings/impl/src/main/java/com/flipperdevices/settings/impl/viewmodels/SettingsViewModel.kt | flipperdevices | 288,258,832 | false | null | package com.flipperdevices.settings.impl.viewmodels
import androidx.datastore.core.DataStore
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.flipperdevices.core.di.ComponentHolder
import com.flipperdevices.core.preference.pb.Settings
import com.flipperdevices.settings.impl.di.SettingsComponent
import javax.inject.Inject
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
class SettingsViewModel : ViewModel() {
@Inject
lateinit var dataStoreSettings: DataStore<Settings>
init {
ComponentHolder.component<SettingsComponent>().inject(this)
}
private val settingsState by lazy {
dataStoreSettings.data.stateIn(
viewModelScope,
SharingStarted.Lazily,
initialValue = Settings.getDefaultInstance()
)
}
fun getState(): StateFlow<Settings> = settingsState
fun onSwitchDebug(value: Boolean) {
viewModelScope.launch {
dataStoreSettings.updateData {
it.toBuilder()
.setEnabledDebugSettings(value)
.build()
}
}
}
fun onSwitchExperimental(value: Boolean) {
viewModelScope.launch {
dataStoreSettings.updateData {
it.toBuilder()
.setEnabledExperimentalFunctions(value)
.build()
}
}
}
}
| 2 | Kotlin | 31 | 293 | 522f873d6dcf09a8f1907c1636fb0c3a996f5b44 | 1,524 | Flipper-Android-App | MIT License |
next/kmp/core/src/commonMain/kotlin/org/dweb_browser/core/std/file/ext/MicroModuleStore.kt | BioforestChain | 594,577,896 | false | null | package org.dweb_browser.core.std.file.ext
import kotlinx.atomicfu.atomic
import kotlinx.coroutines.CompletableDeferred
import kotlinx.coroutines.Deferred
import kotlinx.serialization.ExperimentalSerializationApi
import kotlinx.serialization.cbor.Cbor
import kotlinx.serialization.decodeFromByteArray
import kotlinx.serialization.encodeToByteArray
import org.dweb_browser.core.module.MicroModule
import org.dweb_browser.helper.OrderInvoker
import org.dweb_browser.helper.SafeHashMap
import org.dweb_browser.helper.WeakHashMap
import org.dweb_browser.helper.encodeURIComponent
import org.dweb_browser.helper.getOrPut
import org.dweb_browser.pure.crypto.cipher.cipher_aes_256_gcm
import org.dweb_browser.pure.crypto.decipher.decipher_aes_256_gcm
import org.dweb_browser.pure.crypto.hash.sha256
import org.dweb_browser.pure.http.IPureBody
fun MicroModule.Runtime.createStore(storeName: String, encrypt: Boolean) =
MicroModuleStore(this, storeName, encrypt)
fun MicroModule.Runtime.createStore(
storeName: String,
cipherChunkKey: ByteArray,
encrypt: Boolean,
) = MicroModuleStore(this, storeName, cipherChunkKey, encrypt)
private val defaultSimpleStoreCache by atomic(WeakHashMap<MicroModule.Runtime, MicroModuleStore>())
val MicroModule.Runtime.store: MicroModuleStore
get() = defaultSimpleStoreCache.getOrPut(this) {
createStore("default", true)
}
class MicroModuleStore(
val mm: MicroModule.Runtime,
private val storeName: String,
private val cipherChunkKey: ByteArray?,
private val encrypt: Boolean,
) {
constructor(
mm: MicroModule.Runtime, storeName: String, encrypt: Boolean,
) : this(mm, storeName, null, encrypt)
private val orderInvoker = OrderInvoker()
private suspend fun <T> exec(action: suspend () -> T) =
orderInvoker.tryInvoke(0, invoker = action)
private fun <T> execDeferred(action: suspend () -> T): Deferred<T> {
val deferred = CompletableDeferred<T>()
mm.scopeLaunch(cancelable = true) {
runCatching {
deferred.complete(exec(action))
}.getOrElse {
deferred.completeExceptionally(it)
}
}
return deferred
}
private val cipherPlainKey = mm.mmid + "/" + storeName
private var cipherKey: ByteArray? = null
private val queryPath =
"/data/store/$storeName${if (encrypt) ".ebor" else ".cbor"}".encodeURIComponent()
@OptIn(ExperimentalSerializationApi::class)
private var _store = execDeferred {
if (encrypt) {
cipherKey = if (cipherChunkKey != null) {
sha256(cipherChunkKey)
} else {
sha256(cipherPlainKey)
}
}
try {
mm.debugMM("store-init", queryPath)
val readRequest = mm.readFile(queryPath, true)
val data = readRequest.binary().let {
if (it.isEmpty()) it else cipherKey?.let { key -> decipher_aes_256_gcm(key, it) } ?: it
}
val result: MutableMap<String, ByteArray> = when {
data.isEmpty() -> SafeHashMap()
else -> SafeHashMap(Cbor.decodeFromByteArray(data))
}
mm.debugMM("store-init-data", result)
result
} catch (e: Throwable) {
// debugger(e)
mm.debugMM("store-init-error", null, e)
SafeHashMap()
}
}
suspend fun getStore() = _store.await()
@OptIn(ExperimentalSerializationApi::class)
suspend inline fun <reified T> getAll(): MutableMap<String, T> {
val data = mutableMapOf<String, T>()
for (item in getStore()) {
try { // 使用try的目的是为了保证后面对象字段变更后，存储了新的内容。但由于存在旧数据解析失败导致的所有数据无法获取问题
data[item.key] =
Cbor { ignoreUnknownKeys = true }.decodeFromByteArray<T>(item.value) // 忽略未知的字段
} catch (e: Throwable) {
mm.debugMM("store/getAll", item.key, e)
}
}
return data
}
suspend inline fun clear() {
getStore().clear()
save()
}
@OptIn(ExperimentalSerializationApi::class)
suspend inline fun delete(key: String): Boolean {
val res = getStore().remove(key)
save()
return res !== null
}
@OptIn(ExperimentalSerializationApi::class)
suspend inline fun <reified T> getOrNull(key: String) =
getStore()[key]?.let { Cbor.decodeFromByteArray<T>(it) }
@OptIn(ExperimentalSerializationApi::class)
suspend inline fun <reified T> getOrPut(key: String, put: () -> T): T {
val obj = getStore()
return obj[key].let { it ->
if (it != null) Cbor.decodeFromByteArray<T>(it)
else put().also {
obj[key] = Cbor.encodeToByteArray<T>(it)
save()
}
}
}
suspend inline fun <reified T> get(key: String) = getOrPut<T>(key) {
throw Exception("no found data for key: $key")
}
@OptIn(ExperimentalSerializationApi::class)
suspend fun save() = exec {
val map = getStore()
mm.writeFile(
path = queryPath,
body = IPureBody.from(Cbor.encodeToByteArray(map).let {
cipherKey?.let { key -> cipher_aes_256_gcm(key, it) } ?: it
}),
backup = true,
)
}
@OptIn(ExperimentalSerializationApi::class)
suspend inline fun <reified T> set(key: String, value: T) {
// mm.debugMM("store-set") { "key=$key value=$value" }
val store = getStore()
val newValue = Cbor.encodeToByteArray(value)
if (!newValue.contentEquals(store[key])) {
store[key] = newValue
save()
}
}
} | 66 | null | 5 | 20 | 6db1137257e38400c87279f4ccf46511752cd45a | 5,246 | dweb_browser | MIT License |
testing/cordapps/cashobservers/src/main/kotlin/net/corda/finance/test/flows/CashIssueWithObserversFlow.kt | corda | 70,137,417 | false | null | package net.corda.finance.test.flows
import co.paralleluniverse.fibers.Suspendable
import net.corda.core.contracts.Amount
import net.corda.core.flows.FinalityFlow
import net.corda.core.flows.FlowLogic
import net.corda.core.flows.FlowSession
import net.corda.core.flows.InitiatedBy
import net.corda.core.flows.InitiatingFlow
import net.corda.core.flows.NotaryException
import net.corda.core.flows.ReceiveFinalityFlow
import net.corda.core.flows.StartableByRPC
import net.corda.core.identity.Party
import net.corda.core.node.StatesToRecord
import net.corda.core.transactions.SignedTransaction
import net.corda.core.transactions.TransactionBuilder
import net.corda.core.utilities.OpaqueBytes
import net.corda.finance.contracts.asset.Cash
import net.corda.finance.flows.AbstractCashFlow
import net.corda.finance.flows.CashException
import net.corda.finance.issuedBy
import java.util.Currency
@StartableByRPC
@InitiatingFlow
class CashIssueWithObserversFlow(private val amount: Amount<Currency>,
private val issuerBankPartyRef: OpaqueBytes,
private val notary: Party,
private val observers: Set<Party>) : AbstractCashFlow<AbstractCashFlow.Result>(tracker()) {
@Suspendable
override fun call(): Result {
progressTracker.currentStep = Companion.GENERATING_TX
val builder = TransactionBuilder(notary)
val issuer = ourIdentity.ref(issuerBankPartyRef)
val signers = Cash().generateIssue(builder, amount.issuedBy(issuer), ourIdentity, notary)
progressTracker.currentStep = Companion.SIGNING_TX
val tx = serviceHub.signInitialTransaction(builder, signers)
progressTracker.currentStep = Companion.FINALISING_TX
val observerSessions = observers.map { initiateFlow(it) }
val notarised = finalise(tx, observerSessions, "Unable to notarise issue")
return Result(notarised, ourIdentity)
}
@Suspendable
private fun finalise(tx: SignedTransaction, sessions: Collection<FlowSession>, message: String): SignedTransaction {
try {
return subFlow(FinalityFlow(tx, sessions))
} catch (e: NotaryException) {
throw CashException(message, e)
}
}
}
@InitiatedBy(CashIssueWithObserversFlow::class)
class CashIssueReceiverFlowWithObservers(private val otherSide: FlowSession) : FlowLogic<Unit>() {
@Suspendable
override fun call() {
if (!serviceHub.myInfo.isLegalIdentity(otherSide.counterparty)) {
subFlow(ReceiveFinalityFlow(otherSide, statesToRecord = StatesToRecord.ALL_VISIBLE))
}
}
} | 62 | null | 1089 | 3,989 | d27aa0e6850d3804d0982024054376d452e7073a | 2,652 | corda | Apache License 2.0 |
app/src/main/java/fr/nexhub/homedia/features/common/components/ThumbnailImageCard.kt | valmnt | 795,633,176 | false | null | @file:OptIn(ExperimentalTvMaterial3Api::class)
package fr.nexhub.homedia.features.common.components
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxScope
import androidx.compose.foundation.layout.aspectRatio
import androidx.compose.foundation.layout.width
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.tv.material3.ExperimentalTvMaterial3Api
import androidx.tv.material3.MaterialTheme
import androidx.tv.material3.Text
import fr.nexhub.homedia.theme.HomediaTheme
@Composable
fun ThumbnailImageCard(
modifier: Modifier = Modifier,
content: @Composable (BoxScope.() -> Unit),
) {
Box(
modifier = modifier
.background(
color = MaterialTheme.colorScheme.surface,
shape = MaterialTheme.shapes.small,
).aspectRatio(0.6f),
contentAlignment = Alignment.Center,
) {
content()
}
}
@Preview
@Composable
fun ThumbnailImageCardPreview() {
HomediaTheme {
ThumbnailImageCard(
Modifier
.width(150.dp)
.background(
color = MaterialTheme.colorScheme.onSurface,
shape = MaterialTheme.shapes.small,
),
) {
Text(text = "1x1")
}
}
}
| 7 | null | 0 | 6 | 0cd04aa9cb4944da6be1dd796e827ebc72ac7f05 | 1,520 | homedia | Apache License 2.0 |
frice/src/main/kotlin/org/frice/platform/adapter/DroidDrawer.kt | icela | 69,969,072 | false | {"Gradle": 3, "Shell": 1, "Text": 1, "Ignore List": 1, "Batchfile": 1, "Markdown": 1, "Java Properties": 1, "Proguard": 1, "XML": 3, "Kotlin": 55, "Java": 3} | package org.frice.platform.adapter
import android.graphics.*
import org.frice.platform.FriceDrawer
import org.frice.platform.FriceImage
import org.frice.resource.graphics.ColorResource
import org.frice.utils.cast
/**
* Created by ice1000 on 2016/10/31.
*
* @author ice1000
*/
class DroidDrawer(var canvas: Canvas) : FriceDrawer {
constructor(bitmap: Bitmap) : this(Canvas(bitmap))
val paint = Paint()
override fun init() {
canvas.save()
}
private val rectF = RectF()
override var color: ColorResource
get() = ColorResource(paint.color)
set(value) {
paint.color = value.color
}
val g = canvas
override fun stringSize(size: Double) {
paint.textSize = size.toFloat()
}
override fun drawOval(x: Double, y: Double, width: Double, height: Double) {
rectF.set(x.toFloat(), y.toFloat(), width.toFloat(), height.toFloat())
paint.style = Paint.Style.FILL
g.drawOval(rectF, paint)
}
override fun strokeOval(x: Double, y: Double, width: Double, height: Double) {
rectF.set(x.toFloat(), y.toFloat(), width.toFloat(), height.toFloat())
paint.style = Paint.Style.STROKE
g.drawOval(rectF, paint)
}
override fun drawString(string: String, x: Double, y: Double) {
g.drawText(string, x.toFloat(), y.toFloat(), paint)
}
override fun drawImage(image: FriceImage, x: Double, y: Double) {
g.drawBitmap(cast<DroidImage>(image).image, x.toFloat(), y.toFloat(), paint)
}
override fun drawRect(x: Double, y: Double, width: Double, height: Double) {
rectF.set(x.toFloat(), y.toFloat(), width.toFloat(), height.toFloat())
paint.style = Paint.Style.FILL
g.drawRect(rectF, paint)
}
override fun strokeRect(x: Double, y: Double, width: Double, height: Double) {
rectF.set(x.toFloat(), y.toFloat(), width.toFloat(), height.toFloat())
paint.style = Paint.Style.STROKE
g.drawRect(rectF, paint)
}
override fun drawLine(x: Double, y: Double, width: Double, height: Double) =
g.drawLine(x.toFloat(), y.toFloat(), width.toFloat(), height.toFloat(), paint)
override fun rotate(theta: Double, x: Double, y: Double) = g.rotate(theta.toFloat(), x.toFloat(), y.toFloat())
override fun drawRoundRect(
x: Double,
y: Double,
width: Double,
height: Double,
arcWidth: Double,
arcHeight: Double) {
rectF.set(x.toFloat(), y.toFloat(), width.toFloat(), height.toFloat())
paint.style = Paint.Style.FILL
g.drawRoundRect(rectF, arcWidth.toFloat(), arcHeight.toFloat(), paint)
}
override fun strokeRoundRect(
x: Double,
y: Double,
width: Double,
height: Double,
arcWidth: Double,
arcHeight: Double) {
rectF.set(x.toFloat(), y.toFloat(), width.toFloat(), height.toFloat())
paint.style = Paint.Style.STROKE
g.drawRoundRect(rectF, arcWidth.toFloat(), arcHeight.toFloat(), paint)
}
override fun restore() {
canvas.restore()
}
} | 0 | Kotlin | 0 | 3 | 77cb43e374fcca3f7977c85a6aab870d3d9e0880 | 2,813 | FriceEngine-Android | Apache License 2.0 |
kotest-assertions/kotest-assertions-shared/src/commonMain/kotlin/io/kotest/assertions/until/Interval.kt | kotest | 47,071,082 | false | null | package io.kotest.assertions.until
import kotlin.time.Duration
/**
* A [Interval] determines how often Kotest will invoke the predicate function for an [until] block.
*/
interface Interval {
/**
* Returns the next delay as a [Duration].
*
* @param count The number of times the condition has been polled (evaluated) so far.
* Always a positive integer.
*
* @return The duration of the next poll interval
*/
fun next(count: Int): Duration
}
| 111 | null | 606 | 4,033 | 6c1fd432f9e96ab3581eba3aba91d05bd523e012 | 486 | kotest | Apache License 2.0 |
src/main/kotlin/me/melijn/melijnbot/commands/image/JailCommand.kt | notmynameforreal1 | 364,375,727 | false | null | package me.melijn.melijnbot.commands.image
import com.wrapper.spotify.Base64
import io.lettuce.core.SetArgs
import kotlinx.coroutines.future.await
import me.melijn.melijnbot.internals.command.AbstractCommand
import me.melijn.melijnbot.internals.command.CommandCategory
import me.melijn.melijnbot.internals.command.ICommandContext
import me.melijn.melijnbot.internals.utils.message.sendFileRsp
import me.melijn.melijnbot.internals.utils.message.sendSyntax
import me.melijn.melijnbot.internals.utils.retrieveUserByArgsNMessage
import net.dv8tion.jda.api.Permission
import java.io.ByteArrayOutputStream
import java.net.URL
import javax.imageio.ImageIO
class JailCommand : AbstractCommand("command.jail") {
init {
id = 219
name = "jail"
aliases = arrayOf("jailGif")
discordChannelPermissions = arrayOf(Permission.MESSAGE_ATTACH_FILES)
commandCategory = CommandCategory.IMAGE
}
val jail = JailCommand::class.java.getResourceAsStream("/jail.png").use { ImageIO.read(it) }
override suspend fun execute(context: ICommandContext) {
if (context.args.isEmpty()) {
sendSyntax(context)
return
}
val user = retrieveUserByArgsNMessage(context, 0) ?: return
val rediCon = context.daoManager.driverManager.redisConnection
val avatar = rediCon?.async()
?.get("avatarjailed:${user.id}")
?.await()
val jailedBytesArr = if (avatar == null) {
val inputImg = ImageIO.read(URL(user.effectiveAvatarUrl.replace(".gif", ".png") + "?size=512"))
val graphics = inputImg.graphics
graphics.drawImage(jail, 0, 0, inputImg.width, inputImg.height, null)
graphics.dispose()
ByteArrayOutputStream().use { baos ->
ImageIO.write(inputImg, "png", baos)
baos.toByteArray()
}
} else {
rediCon.async()
.expire("avatarjailed:${user.id}", 600)
Base64.decode(avatar)
}
sendFileRsp(context, "**Go to jail** ${user.asTag} 👮♀️", jailedBytesArr, "png")
rediCon?.async()
?.set("avatarjailed:${user.id}", Base64.encode(jailedBytesArr), SetArgs().ex(600))
}
}
| 0 | Kotlin | 0 | 0 | acf17564244c0c62fba2b85e143d83c6c00c1a86 | 2,267 | 2626 | MIT License |
app/src/main/java/com/example/mvvmkoindiexample/presentation/views/MainActivity.kt | WadeQ | 537,362,318 | false | {"Kotlin": 21833} | package com.example.mvvmkoindiexample.presentation.views
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material.MaterialTheme
import androidx.compose.material.Surface
import androidx.compose.material.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import com.example.mvvmkoindiexample.presentation.viewmodels.PostsViewModel
import com.example.mvvmkoindiexample.ui.theme.MVVMKoinDIExampleTheme
import org.koin.androidx.viewmodel.ext.android.getViewModel
import org.koin.androidx.viewmodel.ext.android.viewModel
class MainActivity : ComponentActivity() {
private val viewModel by viewModel<PostsViewModel>()
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
MVVMKoinDIExampleTheme {
val viewModel = getViewModel<PostsViewModel>()
// A surface container using the 'background' color from the theme
Surface(
modifier = Modifier.fillMaxSize(),
color = MaterialTheme.colors.background
) {
Greeting("Posts size is ${viewModel.state.posts?.size}")
}
}
}
}
}
@Composable
fun Greeting(name: String) {
Text(text = "Hello $name!")
}
@Preview(showBackground = true)
@Composable
fun DefaultPreview() {
MVVMKoinDIExampleTheme {
Greeting("Android")
}
} | 0 | Kotlin | 0 | 0 | df4f3b7ebc9b10793f40ba45d07d0b8da3ec17b3 | 1,643 | Koin-DI-with-MVI | Apache License 2.0 |
src/main/kotlin/com/github/problems/problem1/Solution.kt | frikit | 333,555,449 | false | null | package com.github.problems.problem1
class Solution {
fun findSumInList(list: List<Int>, sum: Int): Boolean {
val cache = hashSetOf<Pair<Int, Int>>()
if (list.isEmpty()) return false
if (list.size == 1 && list.first() != sum) return false
if (list.size == 1 && list.first() == sum) return true
list.forEach { i ->
run {
list.forEach { j ->
run {
if (i != j && !cache.contains(i to j)) {
if (i + j == sum) {
return true
} else {
cache.add(i to j)
}
}
}
}
}
}
return false
}
}
| 0 | Kotlin | 0 | 0 | d5c537d0afd49305ab095b64cfa655501c0c8387 | 835 | daily-coding-problem | Apache License 2.0 |
pack/src/main/kotlin/voodoo/pack/ServerPack.kt | ChrisJStone | 166,379,611 | true | {"Kotlin": 438883, "Shell": 5361, "Ruby": 73} | package voodoo.pack
import voodoo.data.lock.LockPack
import voodoo.util.jenkins.downloadVoodoo
import voodoo.util.toJson
/**
* Created by nikky on 06/05/18.
* @author Nikky
*/
object ServerPack : AbstractPack() {
override val label = "Server SKPack"
override suspend fun pack(
modpack: LockPack,
target: String?,
clean: Boolean
) {
val serverDir = modpack.rootDir.resolve(target ?: "server_${modpack.id}")
if (clean) {
logger.info("cleaning server directory $serverDir")
serverDir.deleteRecursively()
}
serverDir.mkdirs()
val localDir = modpack.localFolder
logger.info("local: $localDir")
if (localDir.exists()) {
val targetLocalDir = serverDir.resolve("local")
modpack.localDir = targetLocalDir.name
if (targetLocalDir.exists()) targetLocalDir.deleteRecursively()
targetLocalDir.mkdirs()
localDir.copyRecursively(targetLocalDir, true)
}
val sourceDir = modpack.sourceFolder // rootFolder.resolve(modpack.rootFolder).resolve(modpack.sourceDir)
logger.info("mcDir: $sourceDir")
if (sourceDir.exists()) {
val targetSourceDir = serverDir.resolve("src")
modpack.sourceDir = targetSourceDir.name
if (targetSourceDir.exists()) targetSourceDir.deleteRecursively()
targetSourceDir.mkdirs()
sourceDir.copyRecursively(targetSourceDir, true)
targetSourceDir.walkBottomUp().forEach { file ->
if (file.name.endsWith(".entry.hjson"))
file.delete()
if (file.isDirectory && file.listFiles().isEmpty()) {
file.delete()
}
when {
file.name == "_CLIENT" -> file.deleteRecursively()
file.name == "_SERVER" -> {
file.copyRecursively(file.absoluteFile.parentFile, overwrite = true)
file.deleteRecursively()
}
}
}
}
val packFile = serverDir.resolve("pack.lock.hjson")
packFile.writeText(modpack.toJson(LockPack.serializer()))
logger.info("packaging installer jar")
val installer =
downloadVoodoo(component = "server-installer", bootstrap = false, binariesDir = directories.cacheHome)
val serverInstaller = serverDir.resolve("server-installer.jar")
installer.copyTo(serverInstaller)
logger.info("server package ready: ${serverDir.absolutePath}")
}
} | 0 | Kotlin | 0 | 0 | b12be54b1802250830070ba8db9538175f8ae7e2 | 2,643 | Voodoo | MIT License |
src/main/java/com/keygenqt/screener/base/Configuration.kt | keygenqt | 254,963,831 | false | null | /*
* Copyright 2020 <NAME>
*
* 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 com.keygenqt.screener.base
import com.keygenqt.screener.utils.PATH_APP_CONFIG
import org.json.JSONArray
import org.json.JSONException
import org.json.JSONObject
import java.io.BufferedReader
import java.io.File
import java.io.FileReader
class Configuration {
companion object {
private var FOLDER_PATH_FOR_SAVE_SCREENSHOT = "Folder path for save screenshot"
private var CLOUD_CREDENTIALS_PATH_TO_FILE = "Cloud credentials path to file"
private var CLOUD_TRANSLATE_LANGUAGE =
"Cloud translate language" // https://cloud.google.com/translate/docs/languages
private var UPLOAD_SCREENSHOT_TO_IMGUR = "Upload screenshot to Imgur"
private var PARAMS = hashMapOf(
FOLDER_PATH_FOR_SAVE_SCREENSHOT to "",
CLOUD_CREDENTIALS_PATH_TO_FILE to "",
UPLOAD_SCREENSHOT_TO_IMGUR to "true"
)
private fun checkParam(key: String): String {
val f = File(PATH_APP_CONFIG)
if (f.exists() && f.isFile) {
try {
val params = JSONObject(BufferedReader(FileReader(f)).readText())
if (params.has(key)) {
when (val value = params.get(key)) {
is String -> {
PARAMS[key] = value
}
is JSONObject -> {
PARAMS[key] = value.toString()
}
is JSONArray -> {
PARAMS[key] = value.toString()
}
}
}
} catch (ex: JSONException) {
println("Error parse config $key")
println(ex)
}
}
return PARAMS[key] ?: ""
}
fun getFolder(): String {
val path = checkParam(FOLDER_PATH_FOR_SAVE_SCREENSHOT)
if (path.contains("{HOME}")) {
return path.replace("{HOME}", System.getProperty("user.home"))
}
return checkParam(FOLDER_PATH_FOR_SAVE_SCREENSHOT)
}
fun getCredentials(): String {
return checkParam(CLOUD_CREDENTIALS_PATH_TO_FILE)
}
fun getLanguage(): String {
return checkParam(CLOUD_TRANSLATE_LANGUAGE)
}
fun isImgur(): Boolean {
return checkParam(UPLOAD_SCREENSHOT_TO_IMGUR) == "true"
}
}
} | 0 | Kotlin | 0 | 0 | 8fdf88a17c590c13ce7324a00f43f9499efecc79 | 3,136 | Screener | Apache License 2.0 |
app/src/main/java/com/etiya/template/data/remote/utils/Constants.kt | Etiya | 700,359,858 | false | {"Kotlin": 14180, "Python": 5781} | package com.etiya.template.data.remote.utils
import com.etiya.template.BuildConfig
object Constants {
const val BASE_URL = BuildConfig.API_URL
const val TABLE_NAME = "BaseEntity"
} | 0 | Kotlin | 0 | 0 | 53da668a8bb68a6597ffd2cee393badff1401f8b | 193 | etiya_android_architecture_template | Apache License 2.0 |
face-detect/src/main/java/soup/nolan/detect/face/FaceDetector.kt | NolanApp | 197,888,252 | false | null | package soup.nolan.detect.face
import android.graphics.Bitmap
import soup.nolan.detect.face.model.Face
import soup.nolan.detect.face.model.Frame
interface FaceDetector : Detector {
fun setCallback(callback: Callback?)
interface Callback {
fun onDetecting(frame: Frame)
fun onDetected(originalImage: Bitmap, faceList: List<Face>)
fun onDetectFailed()
}
}
| 1 | Kotlin | 2 | 9 | 1c7d166034e19ca5774cab43d14a425fdc6fe03e | 397 | Nolan-Android | Apache License 2.0 |
bibix-core/src/main/kotlin/com/giyeok/bibix/plugins/prelude/Glob.kt | Joonsoo | 477,378,536 | false | null | package com.giyeok.bibix.plugins.prelude
import com.giyeok.bibix.base.*
import java.nio.file.Files
import kotlin.io.path.absolute
import kotlin.io.path.absolutePathString
import kotlin.io.path.pathString
class Glob {
fun build(context: BuildContext): SetValue {
val fileSystem = context.fileSystem
val matcher = when (val pattern = context.arguments.getValue("pattern")) {
is StringValue -> {
val matcherPattern =
"glob:" + (context.callerBaseDirectory!!.absolute()).resolve(pattern.value).pathString
fileSystem.getPathMatcher(matcherPattern)
}
is SetValue -> {
val patterns = pattern.values.map { (it as StringValue).value }
TODO()
}
else -> throw AssertionError()
}
val matched = Files.walk(context.callerBaseDirectory).filter { path ->
matcher.matches(path.absolute())
}
val matchedList = matched.map { PathValue(it) }.toList()
return SetValue(matchedList)
}
}
| 9 | null | 1 | 3 | 49c847166eaf16dc99bd52bf40d8417859a960b6 | 979 | bibix | MIT License |
telegram-bot/src/commonMain/kotlin/eu/vendeli/tgbot/types/media/Story.kt | vendelieu | 496,567,172 | false | null | package eu.vendeli.tgbot.types.media
import eu.vendeli.tgbot.types.chat.Chat
import kotlinx.serialization.Serializable
/**
* This object represents a story.
*
* Api reference: https://core.telegram.org/bots/api#story
* @property chat Chat that posted the story
* @property id Unique identifier for the story in the chat
*/
@Serializable
data class Story(
val id: Int,
val chat: Chat,
)
| 2 | null | 9 | 176 | 41d50ea8fd014cb31b61eb5c2f4a4bebf4736b45 | 402 | telegram-bot | Apache License 2.0 |
platform/lang-api/src/com/intellij/execution/target/TargetEnvironmentPaths.kt | hieuprogrammer | 284,920,751 | false | null | // Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
@file:JvmName("TargetEnvironmentPaths")
package com.intellij.execution.target
import com.intellij.execution.Platform
import com.intellij.openapi.util.io.FileUtil
data class PathMapping(val localPath: String, val targetPath: String)
fun TargetEnvironment.getLocalPaths(targetPath: String): List<String> {
return findPathVariants(
mappings = collectPathMappings(),
sourcePath = targetPath,
sourcePathFun = { pathMapping -> pathMapping.targetPath },
sourceFileSeparator = targetPlatform.platform.fileSeparator,
destPathFun = { pathMapping -> pathMapping.localPath },
destFileSeparator = Platform.current().fileSeparator
)
}
fun TargetEnvironment.getTargetPaths(localPath: String): List<String> {
return findPathVariants(
mappings = collectPathMappings(),
sourcePath = localPath,
sourcePathFun = { pathMapping -> pathMapping.localPath },
sourceFileSeparator = Platform.current().fileSeparator,
destPathFun = { pathMapping -> pathMapping.targetPath },
destFileSeparator = targetPlatform.platform.fileSeparator
)
}
private fun TargetEnvironment.collectPathMappings(): List<PathMapping> =
uploadVolumes.values.map { PathMapping(localPath = it.localRoot.toString(), targetPath = it.targetRoot) }
private fun findPathVariants(mappings: Iterable<PathMapping>,
sourcePath: String,
sourcePathFun: (PathMapping) -> String,
sourceFileSeparator: Char,
destPathFun: (PathMapping) -> String,
destFileSeparator: Char): List<String> {
return mappings.mapNotNull { mapping ->
val sourceBase = sourcePathFun(mapping)
if (FileUtil.isAncestor(sourceBase, sourcePath, false)) {
val destBase = destPathFun(mapping)
FileUtil.getRelativePath(sourceBase, sourcePath, sourceFileSeparator)?.let { relativeSourcePath ->
joinTargetPaths(destBase, relativeSourcePath, destFileSeparator)
}
}
else {
null
}
}
}
internal fun joinTargetPaths(basePath: String, relativePath: String, fileSeparator: Char): String {
val resultCanonicalPath = FileUtil.toCanonicalPath("$basePath$fileSeparator$relativePath", fileSeparator)
// The method `FileUtil.toCanonicalPath()` returns the path with '/' no matter what `fileSeparator` is passed but let's make the result
// system-dependent
return FileUtil.toSystemDependentName(resultCanonicalPath, fileSeparator)
} | 1 | null | 1 | 2 | dc846ecb926c9d9589c1ed8a40fdb20e47874db9 | 2,629 | intellij-community | Apache License 2.0 |
kotlin-electron/src/jsMain/generated/electron/core/DesktopCapturer.kt | JetBrains | 93,250,841 | false | null | // Generated by Karakum - do not modify it manually!
package electron.core
import kotlin.js.Promise
external interface DesktopCapturer {
// Docs: https://electronjs.org/docs/api/desktop-capturer
/**
* Resolves with an array of `DesktopCapturerSource` objects, each
* `DesktopCapturerSource` represents a screen or an individual window that can be
* captured.
*
* **Note** Capturing the screen contents requires user consent on macOS 10.15
* Catalina or higher, which can detected by
* `systemPreferences.getMediaAccessStatus`.
*/
fun getSources(options: SourcesOptions): Promise<js.array.ReadonlyArray<DesktopCapturerSource>>
}
| 42 | null | 174 | 1,347 | 997ed3902482883db4a9657585426f6ca167d556 | 679 | kotlin-wrappers | Apache License 2.0 |
system/src/main/kotlin/cn/soybean/system/infrastructure/util/SignUtil.kt | soybeanjs | 467,859,867 | false | null | package cn.soybean.system.infrastructure.util
import cn.soybean.infrastructure.config.consts.AppConstants
import cn.soybean.system.infrastructure.util.SignUtil.createSign
import cn.soybean.system.infrastructure.util.SignUtil.getRandomString
import org.jetbrains.annotations.Contract
import java.nio.charset.StandardCharsets
import java.security.MessageDigest
import java.security.NoSuchAlgorithmException
import java.time.Instant
import java.util.*
import java.util.concurrent.ThreadLocalRandom
import java.util.function.Consumer
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
fun main() {
val paramMap: MutableMap<String, Any> = LinkedHashMap()
paramMap[AppConstants.API_KEY] = "1"
paramMap[AppConstants.API_TIMESTAMP] = Instant.now().toEpochMilli()
paramMap[AppConstants.API_NONCE] = getRandomString(32)
// 更多参数，不限制数量...
// 补全 timestamp、nonce、sign 参数，并序列化为 kv 字符串
val createSign = createSign(paramMap, "HmacSHA256", "1")
println(paramMap)
println(createSign)
}
object SignUtil {
private const val SECRET_KEY = "1"
private const val MD5 = "MD5"
private const val SHA1 = "SHA1"
private const val SHA_256 = "SHA-256"
private const val HMAC_SHA_256 = "HmacSHA256"
/**
* 给 paramsMap 追加 timestamp、nonce、sign 三个参数，并转换为参数字符串，形如：
* `data=xxx8nonce=xxx8timestamp=xxx8sign=xxx`
*
* @param paramsMap 参数列表
* @return 加工后的参数列表 转化为的参数字符串
*/
@Throws(NoSuchAlgorithmException::class)
fun addSignParamsAndJoin(paramsMap: MutableMap<String, Any>, algorithm: String?): String {
// 追加参数
addSignParams(paramsMap, algorithm)
// 拼接参数
return joinParams(paramsMap)
}
/**
* 给 paramsMap 追加 timestamp、nonce、sign 三个参数
*
* @param paramsMap 参数列表
*/
@Throws(NoSuchAlgorithmException::class)
fun addSignParams(paramsMap: MutableMap<String, Any>, algorithm: String?) {
paramsMap[AppConstants.API_TIMESTAMP] = Instant.now().toEpochMilli()
paramsMap[AppConstants.API_NONCE] = getRandomString(32)
paramsMap[AppConstants.API_SIGNATURE] = createSign(paramsMap, algorithm)
}
/**
* 生成指定长度的随机字符串
*
* @param length 字符串的长度
* @return 一个随机字符串
*/
fun getRandomString(length: Int): String {
val str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
val sb = StringBuilder()
for (i in 0 until length) {
val number = ThreadLocalRandom.current().nextInt(62)
sb.append(str[number])
}
return sb.toString()
}
/**
* 创建签名：md5(paramsStr + keyStr)
*
* @param paramsMapIn 参数列表
* @return 签名
*/
@Throws(NoSuchAlgorithmException::class)
fun createSign(paramsMapIn: Map<String, *>, algorithm: String?): String {
// 如果调用者不小心传入了 sign 参数，则此处需要将 sign 参数排除在外
var paramsMap = paramsMapIn
if (paramsMap.containsKey(AppConstants.API_SIGNATURE)) {
// 为了保证不影响原有的 paramsMap，此处需要再复制一份
paramsMap = TreeMap(paramsMap)
paramsMap.remove(AppConstants.API_SIGNATURE)
}
// 计算签名
val paramsStr = joinParamsDictSort(paramsMap)
val fullStr = "$paramsStr&${AppConstants.API_SECRET}=$SECRET_KEY"
return when (algorithm) {
MD5 -> md5(fullStr)
SHA1 -> sha1(fullStr)
SHA_256 -> sha256(fullStr)
HMAC_SHA_256 -> hmacSHA256(paramsStr, SECRET_KEY)
else -> throw RuntimeException("签名非法")
}
}
@Throws(NoSuchAlgorithmException::class)
fun createSign(paramsMapIn: Map<String, *>, algorithm: String?, secretKey: String): String {
// 如果调用者不小心传入了 sign 参数，则此处需要将 sign 参数排除在外
var paramsMap = paramsMapIn
if (paramsMap.containsKey(AppConstants.API_SIGNATURE)) {
// 为了保证不影响原有的 paramsMap，此处需要再复制一份
paramsMap = TreeMap(paramsMap)
paramsMap.remove(AppConstants.API_SIGNATURE)
}
// 计算签名
val paramsStr = joinParamsDictSort(paramsMap)
val fullStr = "$paramsStr&${AppConstants.API_SECRET}=$secretKey"
return when (algorithm) {
MD5 -> md5(fullStr)
SHA1 -> sha1(fullStr)
SHA_256 -> sha256(fullStr)
HMAC_SHA_256 -> hmacSHA256(paramsStr, secretKey)
else -> throw RuntimeException("签名非法")
}
}
/**
* 将所有参数按照字典顺序连接成一个字符串，形如：a=18b=28c=3
*
* @param paramsMapIn 参数列表
* @return 拼接出的参数字符串
*/
private fun joinParamsDictSort(paramsMapIn: Map<String, *>?): String {
// 保证字段按照字典顺序排列
var paramsMap = paramsMapIn
if (paramsMap !is TreeMap<*, *>) {
paramsMap = TreeMap(paramsMap)
}
// 拼接
return joinParams(paramsMap)
}
/**
* 将所有参数连接成一个字符串(不排序)，形如：b=28a=18c=3
*
* @param paramsMap 参数列表
* @return 拼接出的参数字符串
*/
private fun joinParams(paramsMap: Map<String, *>): String {
// 按照 k1=v1&k2=v2&k3=v3 排列
val sb = StringBuilder()
paramsMap.keys.forEach(Consumer { key: String ->
val value = paramsMap[key]
if (!isEmpty(value)) {
sb.append(key).append("=").append(value).append("&")
}
})
// 删除最后一位 &
if (sb.isNotEmpty()) {
sb.deleteCharAt(sb.length - 1)
}
// .
return sb.toString()
}
/**
* 指定元素是否为null或者空字符串
*
* @param str 指定元素
* @return 是否为null或者空字符串
*/
private fun isEmpty(str: Any?): Boolean = str == null || "" == str
/**
* md5加密
*
* @param strIn 指定字符串
* @return 加密后的字符串
*/
@Contract("_ -> new")
@Throws(NoSuchAlgorithmException::class)
fun md5(strIn: String?): String {
val str = strIn ?: ""
val hexDigits = charArrayOf('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f')
val btInput = str.toByteArray()
val mdInst = MessageDigest.getInstance(MD5)
mdInst.update(btInput)
val md = mdInst.digest()
val j = md.size
val strA = CharArray(j * 2)
var k = 0
for (byte0 in md) {
strA[k++] = hexDigits[byte0.toInt() ushr 4 and 0xf]
strA[k++] = hexDigits[byte0.toInt() and 0xf]
}
return String(strA)
}
/**
* sha1加密
*
* @param strIn 指定字符串
* @return 加密后的字符串
*/
@Contract("_ -> new")
@Throws(NoSuchAlgorithmException::class)
fun sha1(strIn: String?): String {
val str = strIn ?: ""
val md = MessageDigest.getInstance(SHA1)
val b = str.toByteArray()
md.update(b)
val b2 = md.digest()
val len = b2.size
val strA = "0123456789abcdef"
val ch = strA.toCharArray()
val chs = CharArray(len * 2)
var i = 0
var k = 0
while (i < len) {
val b3 = b2[i]
chs[k++] = ch[b3.toInt() ushr 4 and 0xf]
chs[k++] = ch[b3.toInt() and 0xf]
i++
}
return String(chs)
}
/**
* sha256加密
*
* @param strIn 指定字符串
* @return 加密后的字符串
*/
@Throws(NoSuchAlgorithmException::class)
fun sha256(strIn: String?): String {
val str = strIn ?: ""
val messageDigest = MessageDigest.getInstance(SHA_256)
messageDigest.update(str.toByteArray(StandardCharsets.UTF_8))
val bytes = messageDigest.digest()
val builder = StringBuilder()
var temp: String
for (aByte in bytes) {
temp = Integer.toHexString(aByte.toInt() and 0xFF)
if (temp.length == 1) {
builder.append("0")
}
builder.append(temp)
}
return builder.toString()
}
@Throws(NoSuchAlgorithmException::class)
fun hmacSHA256(strIn: String?, secret: String): String {
val str = strIn ?: ""
val secretKeySpec = SecretKeySpec(secret.toByteArray(StandardCharsets.UTF_8), HMAC_SHA_256)
val mac = Mac.getInstance(HMAC_SHA_256)
mac.init(secretKeySpec)
val bytes = mac.doFinal(str.toByteArray(StandardCharsets.UTF_8))
return bytes.joinToString("") { "%02x".format(it) }
}
}
| 4 | null | 92 | 223 | 4a1a7dc91aaa608d9110c81b6a60d83fbec7d25a | 8,304 | soybean-admin-quarkus | MIT License |
server/src/test/java/org/jetbrains/bsp/bazel/server/bloop/ClasspathRewriterTest.kt | JetBrains | 288,953,714 | false | null | package org.jetbrains.bsp.bazel.server.bloop
import io.kotest.matchers.collections.shouldContainExactly
import org.junit.jupiter.api.Test
import java.nio.file.Paths
class ClasspathRewriterTest {
@Test
fun `rewrites classpath`() {
val root = Paths.get("root/")
val localRoot = Paths.get("local-root/")
val artifacts = mapOf(
root.resolve("artifact-1").toUri() to localRoot.resolve("local-artifact-1").toUri()
)
val rewriter = ClasspathRewriter(artifacts)
val ret = rewriter.rewrite(
listOf(
root.resolve("artifact-1").toUri(),
root.resolve("artifact-2").toUri()
)
)
ret.shouldContainExactly(
localRoot.resolve("local-artifact-1").toAbsolutePath(),
root.resolve("artifact-2").toAbsolutePath()
)
}
}
| 6 | Kotlin | 32 | 112 | 5eb42d2e8c6a8405ba401d583600993b1b3dd1c8 | 877 | bazel-bsp | Apache License 2.0 |
DriverDataUI/src/main/java/com/drivequant/drivekit/ui/commons/views/DistractionSelectorItem.kt | DriveQuantPublic | 216,339,559 | false | {"Gradle": 12, "Java Properties": 2, "Shell": 1, "Text": 1, "Ignore List": 10, "Batchfile": 1, "Markdown": 1, "INI": 8, "Proguard": 9, "XML": 419, "Kotlin": 478, "Java": 1} | package com.drivequant.drivekit.ui.commons.views
import android.content.Context
import android.graphics.drawable.GradientDrawable
import android.util.AttributeSet
import android.view.View
import android.view.ViewGroup
import android.widget.LinearLayout
import android.widget.TextView
import androidx.core.content.ContextCompat
import androidx.core.graphics.drawable.DrawableCompat
import com.drivequant.drivekit.common.ui.DriveKitUI
import com.drivequant.drivekit.common.ui.extension.smallText
import com.drivequant.drivekit.ui.R
internal class DistractionSelectorItem : LinearLayout {
private lateinit var distractionSelectorTextView: TextView
constructor(context: Context) : super(context) {
init()
}
constructor(context: Context, attrs: AttributeSet) : super(context, attrs) {
init()
}
private fun init() {
val view = View.inflate(context, R.layout.dk_distraction_selector_item, null)
addView(
view, ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT
)
)
this.distractionSelectorTextView = view.findViewById(R.id.distraction_selector)
}
fun setSelectorContent(content: String) {
distractionSelectorTextView.text = content
}
fun setSelection(selected: Boolean) {
val drawable = (distractionSelectorTextView.background as GradientDrawable).mutate()
DrawableCompat.setTint(
drawable,
if (selected) DriveKitUI.colors.secondaryColor()
else ContextCompat.getColor(context, R.color.dkDistractionSelectorColor)
)
distractionSelectorTextView.smallText(
textColor = if (selected) DriveKitUI.colors.fontColorOnSecondaryColor() else DriveKitUI.colors.primaryColor(),
isTypeFaceBold = true
)
}
}
| 0 | Kotlin | 3 | 9 | e7956263157c49aae8d6f993a558ea77d9658ee6 | 1,896 | drivekit-ui-android | Apache License 2.0 |
identity/src/main/java/io/falu/identity/selfie/SelfieFragment.kt | tinglesoftware | 345,511,436 | false | null | package io.falu.identity.selfie
import android.net.Uri
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.camera.core.CameraSelector
import androidx.fragment.app.Fragment
import androidx.fragment.app.activityViewModels
import androidx.lifecycle.ViewModelProvider
import io.falu.core.models.FaluFile
import io.falu.identity.IdentityVerificationViewModel
import io.falu.identity.R
import io.falu.identity.ai.FaceDetectionAnalyzer
import io.falu.identity.api.models.UploadMethod
import io.falu.identity.api.models.verification.Verification
import io.falu.identity.api.models.verification.VerificationSelfieUpload
import io.falu.identity.api.models.verification.VerificationUploadRequest
import io.falu.identity.camera.CameraView
import io.falu.identity.databinding.FragmentSelfieBinding
import io.falu.identity.utils.*
import io.falu.identity.utils.navigateToApiResponseProblemFragment
import io.falu.identity.utils.navigateToErrorFragment
import io.falu.identity.utils.submitVerificationData
import io.falu.identity.utils.updateVerification
import software.tingle.api.patch.JsonPatchDocument
internal class SelfieFragment(identityViewModelFactory: ViewModelProvider.Factory) : Fragment() {
private val identityViewModel: IdentityVerificationViewModel by activityViewModels { identityViewModelFactory }
private var _binding: FragmentSelfieBinding? = null
private val binding get() = _binding!!
private lateinit var verificationRequest: VerificationUploadRequest
private lateinit var analyzer: FaceDetectionAnalyzer
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
_binding = FragmentSelfieBinding.inflate(inflater, container, false)
return binding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
verificationRequest =
requireNotNull(VerificationUploadRequest.getFromBundle(requireArguments())) {
"Verification upload request is null"
}
binding.viewCamera.lifecycleOwner = viewLifecycleOwner
binding.viewCamera.lensFacing = CameraSelector.LENS_FACING_FRONT
binding.viewCamera.cameraViewType = CameraView.CameraViewType.FACE
binding.buttonContinue.text = getString(R.string.button_continue)
identityViewModel.observeForVerificationResults(
viewLifecycleOwner,
onError = {},
onSuccess = { initiateAnalyzer(it) }
)
binding.buttonTakeSelfie.setOnClickListener {
binding.viewCamera.takePhoto(
onCaptured = { analyzeImage(it) },
onCaptureError = { navigateToErrorFragment(it) }
)
}
binding.buttonReset.setOnClickListener {
binding.viewSelfieCamera.visibility = View.VISIBLE
binding.viewSelfieResult.visibility = View.GONE
}
}
private fun initiateAnalyzer(verification: Verification) {
identityViewModel.faceDetectorModelFile.observe(viewLifecycleOwner) {
if (it != null) {
analyzer = FaceDetectionAnalyzer(
it,
verification.capture.models.face?.score?.toFraction() ?: threshold
)
}
}
}
private fun bindToUI(uri: Uri) {
binding.viewSelfieCamera.visibility = View.GONE
binding.viewSelfieResult.visibility = View.VISIBLE
binding.viewSelfieError.visibility = View.GONE
binding.buttonContinue.visibility = View.VISIBLE
binding.cvSelfie.visibility = View.VISIBLE
binding.ivSelfie.setImageURI(uri)
binding.buttonContinue.setOnClickListener {
binding.buttonContinue.showProgress()
uploadSelfie(uri)
}
}
private fun bindToUIWithError() {
binding.viewSelfieCamera.visibility = View.GONE
binding.viewSelfieResult.visibility = View.VISIBLE
binding.viewSelfieError.visibility = View.VISIBLE
binding.cvSelfie.visibility = View.GONE
binding.buttonContinue.visibility = View.GONE
}
private fun uploadSelfie(uri: Uri) {
identityViewModel.uploadSelfieImage(
uri,
onSuccess = { submitSelfieAndUploadedDocuments(it) },
onFailure = { navigateToErrorFragment(it) },
onError = { navigateToApiResponseProblemFragment(it) },
)
}
private fun submitSelfieAndUploadedDocuments(file: FaluFile) {
val selfie =
VerificationSelfieUpload(
UploadMethod.MANUAL,
file = file.id,
variance = 0F,
)
val document = JsonPatchDocument().replace("/selfie", selfie)
updateVerification(identityViewModel, document, R.id.fragment_selfie, onSuccess = {
selfie.camera = binding.viewCamera.cameraSettings
verificationRequest.selfie = selfie
submitVerificationData(identityViewModel, R.id.fragment_selfie, verificationRequest)
})
}
private fun analyzeImage(uri: Uri?) {
val selfieUri = requireNotNull(uri) {
"Selfie uri is null"
}
val output = analyzer.analyze(
selfieUri.toBitmap(requireContext().contentResolver)
)
if (output.score >= threshold) {
bindToUI(selfieUri)
return
}
// show selfie capture error results.
bindToUIWithError()
}
override fun onDestroyView() {
super.onDestroyView()
_binding = null
}
companion object {
private const val threshold = 0.85f
}
} | 0 | Kotlin | 0 | 0 | 78ab41e760b81f9ba7b1ec53d9c7d11630bd2b87 | 5,830 | falu-android | MIT License |
react-query-kotlin/src/jsMain/kotlin/tanstack/query/core/InfiniteQueryObserverSuccessResult.kt | karakum-team | 393,199,102 | false | {"Kotlin": 6212172} | // Automatically generated - do not modify!
package tanstack.query.core
import js.core.Void
external interface InfiniteQueryObserverSuccessResult<TData, TError>
: InfiniteQueryObserverResult<TData, TError> {
override val data: TData
override val error: Void
override val isError: False
override val isPending: False
override val isLoadingError: False
override val isRefetchError: False
override val isSuccess: True
override val status: QueryStatus /* 'success' */
}
| 32 | Kotlin | 8 | 35 | e681a7be1ea3bcd97be311cedfb614c3a1b5bbc6 | 505 | types-kotlin | Apache License 2.0 |
tmp/arrays/youTrackTests/1711.kt | DaniilStepanov | 228,623,440 | false | null | // Original bug: KT-40308
import kotlin.reflect.KProperty
class SomeType
class OtherType
class SomeDelegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>) = "Delegated!"
}
class OtherDelegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>) = "Delegated!"
}
class Test {
companion object {
val SomeType.test by SomeDelegate()
val OtherType.test by OtherDelegate()
}
fun test() {
println(SomeType().test)
}
}
fun main() {
Test().test()
}
| 1 | null | 8 | 1 | 602285ec60b01eee473dcb0b08ce497b1c254983 | 529 | bbfgradle | Apache License 2.0 |
korge-build/jvm/src/main/kotlin/com/soywiz/korge/build/ResourceVersion.kt | wiltonlazary | 83,857,620 | true | {"Kotlin": 609504, "Java": 182756, "ActionScript": 7295, "HTML": 174} | package com.soywiz.korge.build
import com.soywiz.korio.crypto.AsyncHash
import com.soywiz.korio.crypto.hash
import com.soywiz.korio.serialization.Mapper
import com.soywiz.korio.serialization.json.Json
import com.soywiz.korio.util.toHexStringLower
import com.soywiz.korio.vfs.VfsFile
data class ResourceVersion(val name: String, val loaderVersion: Int, val sha1: String, val configSha1: String = "") {
suspend fun writeMeta(metaFile: VfsFile) {
metaFile.writeString(Json.encode(this))
}
companion object {
init {
Mapper.registerType(ResourceVersion::class) {
ResourceVersion(it["name"].gen(), it["loaderVersion"].gen(), it["sha1"].gen(), it["configSha1"].gen())
}
Mapper.registerUntype(ResourceVersion::class) {
mapOf(
"name" to it.name,
"loaderVersion" to it.loaderVersion,
"sha1" to it.sha1,
"configSha1" to it.configSha1
)
}
}
suspend fun fromFile(file: VfsFile, loaderVersion: Int): ResourceVersion {
val configFile = file.appendExtension("config")
val hash = file.readBytes().hash(AsyncHash.SHA1).toHexStringLower()
val configHash = if (configFile.exists()) configFile.readBytes().hash(AsyncHash.SHA1).toHexStringLower() else ""
return ResourceVersion(file.basename, loaderVersion, hash, configHash)
}
suspend fun readMeta(metaFile: VfsFile): ResourceVersion {
return Json.decodeToType<ResourceVersion>(metaFile.readString())
}
}
}
| 0 | Kotlin | 0 | 0 | 2d3c7ed5b63f64cea73537707d7937be24168d6d | 1,418 | korge | Apache License 2.0 |
compiler/testData/ir/irText/fakeOverrides/collections/list/listOverrideKJJ.kt | JetBrains | 3,432,266 | false | {"Kotlin": 79571273, "Java": 6776465, "Swift": 4063829, "C": 2609744, "C++": 1957654, "Objective-C++": 175279, "JavaScript": 130754, "Python": 59855, "Shell": 34920, "Objective-C": 21463, "Lex": 21452, "Batchfile": 11382, "CSS": 11368, "Ruby": 10470, "Dockerfile": 9907, "Groovy": 7092, "EJS": 5241, "CMake": 4473, "HTML": 2699, "Puppet": 1698, "FreeMarker": 1393, "Roff": 725, "Scala": 80} | // SKIP_KT_DUMP
// TARGET_BACKEND: JVM
// FULL_JDK
// SEPARATE_SIGNATURE_DUMP_FOR_K2
// ^ ISSUE: KT-65219, KT-63914
// FILE: Java1.java
import java.util.ArrayList;
public class Java1 extends ArrayList<Integer>{ }
// FILE: 1.kt
class A : Java1()
class B : Java1() {
override fun remove(element: Int?): Boolean {
return true
}
override val size: Int
get() = 5
override fun removeAt(index: Int): Int {
return 1
}
}
fun test(a: A, b: B) {
a.size
a.add(null)
a.add(1)
a.add(2,2)
a.get(1)
a.remove(1)
a.removeAt(1)
b.size
b.add(null)
b.add(2)
b.add(2,2)
b.get(1)
b.remove(null)
b.removeAt(1)
} | 181 | Kotlin | 5748 | 49,172 | 33eb9cef3d146062c103f9853d772f0a1da0450e | 693 | kotlin | Apache License 2.0 |
pop-miners/veriblock-pop-miners-common/src/main/kotlin/org/veriblock/miners/pop/model/result/SuccessResultMessage.kt | VeriBlock | 179,742,374 | false | null | // VeriBlock PoP Miner
// Copyright 2017-2020 <NAME>
// All rights reserved.
// https://www.veriblock.org
// Distributed under the MIT software license, see the accompanying
// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
package org.veriblock.miners.pop.model.result
class SuccessResultMessage : ResultMessage {
override val code: String
get() = "V200"
override val message: String
get() = "Success"
override val details: List<String>
get() = emptyList()
override val isError: Boolean
get() = false
}
| 72 | null | 16 | 12 | ef06c51c1410ba59da13403b65e367b21dcfed21 | 577 | nodecore | MIT License |
apps/shared/src/commonMain/kotlin/com/github/kittinunf/cored/app/repository/UserRepository.kt | kittinunf | 361,204,567 | false | null | package com.github.kittinunf.cored.app.repository
import com.github.kittinunf.cored.app.api.User
import io.ktor.client.HttpClient
import io.ktor.client.features.defaultRequest
import io.ktor.client.features.json.Json
import io.ktor.client.features.json.serializer.KotlinxSerializer
import io.ktor.client.request.get
import io.ktor.http.URLProtocol
interface UserRepository {
suspend fun getUsers(): List<User>?
}
class UserRepositoryImpl(private val client: HttpClient = createHttpClient()) : UserRepository {
override suspend fun getUsers(): List<User>? {
return try {
client.get<List<User>>("/users")
} catch (e: Exception) {
println(e.stackTraceToString())
null
}
}
}
private fun createHttpClient() = HttpClient {
Json {
serializer = KotlinxSerializer()
}
defaultRequest {
url {
protocol = URLProtocol.HTTPS
host = "jsonplaceholder.typicode.com"
}
}
}
| 1 | Kotlin | 1 | 25 | a5825ddb775c0ff54fddd63ef0a7f85644a10cfd | 1,000 | CoRed | MIT License |
app/src/main/java/com/boolder/boolder/view/offlinephotos/composable/OfflinePhotosAreaItem.kt | boolder-org | 566,723,758 | false | {"Kotlin": 532905} | package com.boolder.boolder.view.offlinephotos.composable
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.foundation.shape.CircleShape
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material3.CircularProgressIndicator
import androidx.compose.material3.Icon
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.livedata.observeAsState
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.clip
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.TransformOrigin
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalInspectionMode
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.style.TextOverflow
import androidx.compose.ui.tooling.preview.PreviewLightDark
import androidx.compose.ui.tooling.preview.PreviewParameter
import androidx.compose.ui.tooling.preview.PreviewParameterProvider
import androidx.compose.ui.unit.dp
import androidx.work.WorkInfo
import androidx.work.WorkManager
import com.boolder.boolder.R
import com.boolder.boolder.offline.DOWNLOAD_TERMINATED_STATUSES
import com.boolder.boolder.offline.WORK_DATA_PROGRESS
import com.boolder.boolder.offline.WORK_DATA_PROGRESS_DETAIL
import com.boolder.boolder.offline.getDownloadTopoImagesWorkName
import com.boolder.boolder.view.compose.BoolderTheme
import com.boolder.boolder.view.offlinephotos.model.OfflineAreaItemStatus
@Composable
fun OfflinePhotosAreaItem(
areaName: String,
status: OfflineAreaItemStatus,
onDownloadClicked: () -> Unit,
onDownloadTerminated: () -> Unit,
onCancelDownload: () -> Unit,
onDeleteClicked: () -> Unit,
modifier: Modifier = Modifier
) {
val shape = RoundedCornerShape(8.dp)
val internalModifier = modifier
.fillMaxWidth()
.height(56.dp)
.clip(shape)
.background(color = MaterialTheme.colorScheme.surface)
when (status) {
is OfflineAreaItemStatus.NotDownloaded -> OfflinePhotosAreaNotDownloadedItem(
modifier = internalModifier,
areaName = areaName,
onDownloadClicked = onDownloadClicked
)
is OfflineAreaItemStatus.Downloading -> OfflinePhotosAreaDownloadingItem(
modifier = internalModifier,
areaName = areaName,
areaId = status.areaId,
onDownloadTerminated = onDownloadTerminated,
onCancelDownload = onCancelDownload
)
is OfflineAreaItemStatus.Downloaded -> OfflinePhotosAreaDownloadedItem(
modifier = internalModifier,
areaName = areaName,
folderSize = status.folderSize,
onDeleteClicked = onDeleteClicked
)
}
}
@Composable
private fun OfflinePhotosAreaNotDownloadedItem(
areaName: String,
onDownloadClicked: () -> Unit,
modifier: Modifier = Modifier
) {
Row(
modifier = modifier.padding(8.dp),
horizontalArrangement = Arrangement.Absolute.spacedBy(16.dp),
verticalAlignment = Alignment.CenterVertically
) {
AreaName(
modifier = Modifier
.weight(1f)
.padding(start = 8.dp),
areaName = areaName
)
Icon(
modifier = Modifier
.clip(CircleShape)
.clickable(onClick = onDownloadClicked)
.padding(8.dp),
painter = painterResource(id = R.drawable.ic_download_for_offline),
contentDescription = null,
tint = MaterialTheme.colorScheme.primary
)
}
}
@Composable
private fun OfflinePhotosAreaDownloadingItem(
areaName: String,
areaId: Int,
onDownloadTerminated: () -> Unit,
onCancelDownload: () -> Unit,
modifier: Modifier = Modifier
) {
Box(
modifier = modifier,
contentAlignment = Alignment.CenterStart
) {
val progressModifier = Modifier
.fillMaxWidth()
.height(56.dp)
if (LocalInspectionMode.current) {
Box(
modifier = progressModifier
.graphicsLayer {
transformOrigin = TransformOrigin(0f, 0f)
scaleX = .4f
}
.background(color = Color.Gray.copy(alpha = .3f))
)
OfflinePhotosAreaDownloadingItemContent(
areaName = areaName,
progressDetail = "4/10",
onCancelDownload = {}
)
} else {
val workInfoList by WorkManager.getInstance(LocalContext.current)
.getWorkInfosForUniqueWorkLiveData(areaId.getDownloadTopoImagesWorkName())
.observeAsState()
if (workInfoList?.all { it.state in DOWNLOAD_TERMINATED_STATUSES } == true) {
onDownloadTerminated()
}
val workInfo = workInfoList
?.firstOrNull { it.state == WorkInfo.State.RUNNING }
?: return@Box
val progress = workInfo.progress
.getFloat(WORK_DATA_PROGRESS, 0f)
Box(
modifier = progressModifier
.graphicsLayer {
transformOrigin = TransformOrigin(0f, 0f)
scaleX = progress
}
.background(
color = MaterialTheme.colorScheme.onSurfaceVariant.copy(alpha = .3f)
)
)
val progressDetail = workInfo.progress
.getString(WORK_DATA_PROGRESS_DETAIL)
OfflinePhotosAreaDownloadingItemContent(
areaName = areaName,
progressDetail = progressDetail,
onCancelDownload = onCancelDownload
)
}
}
}
@Composable
private fun OfflinePhotosAreaDownloadingItemContent(
areaName: String,
progressDetail: String?,
onCancelDownload: () -> Unit
) {
Row(
modifier = Modifier.padding(8.dp),
horizontalArrangement = Arrangement.Absolute.spacedBy(16.dp),
verticalAlignment = Alignment.CenterVertically
) {
CircularProgressIndicator(
modifier = Modifier
.padding(start = 8.dp)
.size(24.dp)
)
AreaName(
modifier = Modifier.weight(1f),
areaName = areaName
)
if (!progressDetail.isNullOrEmpty()) {
Text(
text = "($progressDetail)",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurface
)
}
Icon(
modifier = Modifier
.clip(CircleShape)
.clickable(onClick = onCancelDownload)
.padding(8.dp),
painter = painterResource(id = R.drawable.ic_cancel),
contentDescription = null,
tint = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
@Composable
private fun OfflinePhotosAreaDownloadedItem(
areaName: String,
folderSize: String,
onDeleteClicked: () -> Unit,
modifier: Modifier = Modifier
) {
Row(
modifier = modifier.padding(8.dp),
horizontalArrangement = Arrangement.Absolute.spacedBy(16.dp),
verticalAlignment = Alignment.CenterVertically
) {
Icon(
modifier = Modifier
.padding(start = 8.dp)
.size(24.dp),
painter = painterResource(id = R.drawable.ic_download_done),
contentDescription = null,
tint = MaterialTheme.colorScheme.primary
)
AreaName(
modifier = Modifier.weight(1f),
areaName = areaName
)
Text(
text = "($folderSize)",
style = MaterialTheme.typography.bodySmall,
color = MaterialTheme.colorScheme.onSurface
)
Icon(
modifier = Modifier
.clip(CircleShape)
.clickable(onClick = onDeleteClicked)
.padding(8.dp),
painter = painterResource(id = R.drawable.ic_delete_forever),
contentDescription = null,
tint = MaterialTheme.colorScheme.onSurfaceVariant
)
}
}
@Composable
private fun AreaName(
areaName: String,
modifier: Modifier = Modifier
) {
Text(
modifier = modifier,
text = areaName,
style = MaterialTheme.typography.bodyMedium,
color = MaterialTheme.colorScheme.onSurface,
maxLines = 2,
overflow = TextOverflow.Ellipsis
)
}
@PreviewLightDark
@Composable
private fun OfflinePhotosAreaItemPreview(
@PreviewParameter(OfflinePhotosAreaItemPreviewParameterProvider::class)
status: OfflineAreaItemStatus
) {
BoolderTheme {
OfflinePhotosAreaItem(
modifier = Modifier
.background(color = MaterialTheme.colorScheme.background)
.padding(16.dp),
areaName = "Apremont",
status = status,
onDownloadClicked = {},
onDownloadTerminated = {},
onCancelDownload = {},
onDeleteClicked = {}
)
}
}
private class OfflinePhotosAreaItemPreviewParameterProvider :
PreviewParameterProvider<OfflineAreaItemStatus> {
override val values = sequenceOf(
OfflineAreaItemStatus.NotDownloaded,
OfflineAreaItemStatus.Downloading(areaId = 7),
OfflineAreaItemStatus.Downloaded(folderSize = "50 MB"),
)
}
| 7 | Kotlin | 9 | 26 | dd93a7b9c29ee0eec80b63a62de4b5eea7203f6e | 10,239 | boolder-android | MIT License |
src/main/java/balti/module/baltitoolbox/functions/FileHandlers.kt | BaltiApps | 424,933,438 | true | {"Kotlin": 45769} | package balti.module.baltitoolbox.functions
import android.annotation.SuppressLint
import android.os.Environment
import balti.module.baltitoolbox.R
import balti.module.baltitoolbox.ToolboxHQ
import balti.module.baltitoolbox.functions.FileHandlers.INTERNAL_TYPE.*
import java.io.*
@SuppressLint("StaticFieldLeak")
object FileHandlers {
private val context = ToolboxHQ.context
private fun copyStream(inputStream: InputStream, outputStream: OutputStream): String{
var read: Int
val buffer = ByteArray(4096)
return try {
while (true) {
read = inputStream.read(buffer)
if (read > 0) outputStream.write(buffer, 0, read)
else break
}
outputStream.close()
return ""
} catch (e: IOException){
e.printStackTrace()
e.message.toString()
}
}
/**
* Allows to specify kind of parent to be used in [getInternalFile], [unpackAssetToInternal]
*
* @property[INTERNAL_FILES] Parent should be [android.content.Context.getFilesDir]
* @property[INTERNAL_CACHE] Parent should be [android.content.Context.getCacheDir]
* @property[EXTERNAL_FILES] Parent should be [android.content.Context.getExternalFilesDir] (null type)
* @property[EXTERNAL_CACHE] Parent should be [android.content.Context.getExternalCacheDir]
*/
enum class INTERNAL_TYPE {
INTERNAL_FILES,
INTERNAL_CACHE,
EXTERNAL_FILES,
EXTERNAL_CACHE
}
/**
* Get a File object using a specified parent.
* Parent can be specified using a type from [INTERNAL_TYPE]
*
* @param[fileName] A string for file name
* @param[internalType] A type from one of [INTERNAL_TYPE]
*
* @return A File object with parent as specified by [fileName]
*/
fun getInternalFile(fileName: String, internalType: INTERNAL_TYPE = INTERNAL_TYPE.INTERNAL_FILES): File =
File(
when(internalType){
INTERNAL_TYPE.INTERNAL_FILES -> context.filesDir
INTERNAL_TYPE.INTERNAL_CACHE -> context.cacheDir
INTERNAL_TYPE.EXTERNAL_CACHE -> context.externalCacheDir
INTERNAL_TYPE.EXTERNAL_FILES -> context.getExternalFilesDir(null)
}, fileName
)
/**
* Extract an asset from the apk
*
* @param[assetFileName] Exact name of the asset
* @param[destination] File destination where the asset is to be extracted
*
* @return Error occurred during extract. Empty string if no error.
*/
fun unpackAsset(assetFileName: String, destination: File): String {
val assetManager = context.assets
val unpackFile = destination.let {
if (it.isDirectory) File(it, assetFileName)
else it
}
unpackFile.run {
mkdirs()
if (!canWrite()) return "${context.getString(R.string.cannot_write_on_destination)} ${unpackFile.absolutePath}"
else if (unpackFile.exists()) unpackFile.delete()
}
val inputStream = assetManager.open(assetFileName)
val outputStream = FileOutputStream(unpackFile)
return copyStream(inputStream, outputStream)
}
/**
* Similar to [unpackAsset] but extracts an asset only in a 'internal' location of the app.
* 'internal' meaning either the apps private data directory, private directory on the SD card
*
* @param[assetFileName] Exact name of the asset
* @param[destinationName] A string specifying the name of the extracted asset.
* Difference with that of destination of [unpackAsset] is that [destinationName] only accepts
* a string to define the final extracted asset file name, not the location of extraction.
* @param[internalType] An internal parent type of [INTERNAL_TYPE]
*
* @return A string file path to the extracted asset, if extraction is successful, else a blank string
*/
fun unpackAssetToInternal(assetFileName: String, destinationName: String = assetFileName, internalType: INTERNAL_TYPE = INTERNAL_FILES): String {
val d = getInternalFile(destinationName, internalType)
return unpackAsset(assetFileName, d).let {
if (it == "") d.absolutePath
else ""
}
}
fun copyFileStream(sourceFile: File, destination: String): String {
if (!(sourceFile.exists() && sourceFile.canRead())) return "${context.getString(R.string.source_does_not_exist)} ${sourceFile.absolutePath}"
val destinationFile = File(destination).let {
if (it.isDirectory) File(it, sourceFile.name)
else it
}
destinationFile.run {
mkdirs()
if (!canWrite()) return "${context.getString(R.string.cannot_write_on_destination)} ${destinationFile.absolutePath}"
else if (destinationFile.exists()) destinationFile.delete()
}
val inputStream = sourceFile.inputStream()
val outputStream = FileOutputStream(destinationFile)
return copyStream(inputStream, outputStream)
}
fun copyFileStream(sourceFile: File, destinationFile: File): String = copyFileStream(sourceFile, destinationFile.absolutePath)
fun moveFileStream(sourceFile: File, destination: String): String {
val r = copyFileStream(sourceFile, destination)
sourceFile.delete()
return r
}
fun moveFileStream(sourceFile: File, destinationFile: File): String = moveFileStream(sourceFile, destinationFile.absolutePath)
fun getDirLength(directoryPath: String): Long {
val file = File(directoryPath)
return if (file.exists()) {
if (!file.isDirectory) file.length()
else {
var sum = 0L
file.listFiles()?.let {
for (f in it) sum += getDirLength(f.absolutePath)
}
sum
}
} else 0
}
fun getDirLength(directory: File): Long = getDirLength(directory.absolutePath)
fun dirDelete(path: String) {
val file = File(path)
if (file.exists() && file.absolutePath != Environment.getExternalStorageDirectory().absolutePath) {
file.deleteRecursively()
}
}
} | 0 | Kotlin | 1 | 5 | a14d7b582496a6f7592c8b98ac1a778d125cb672 | 6,417 | baltitoolbox | Apache License 2.0 |
firebase-firestore/src/commonMain/kotlin/dev/gitlive/firebase/firestore/TimestampSerializer.kt | GitLiveApp | 213,915,094 | false | {"Kotlin": 712421, "Ruby": 18024, "JavaScript": 469} | package dev.gitlive.firebase.firestore
import dev.gitlive.firebase.internal.SpecialValueSerializer
import dev.gitlive.firebase.firestore.DoubleAsTimestampSerializer.SERVER_TIMESTAMP
import kotlinx.serialization.KSerializer
import kotlinx.serialization.SerializationException
/** A serializer for [BaseTimestamp]. Must be used with [FirebaseEncoder]/[FirebaseDecoder]. */
public object BaseTimestampSerializer : KSerializer<BaseTimestamp> by SpecialValueSerializer(
serialName = "Timestamp",
toNativeValue = { value ->
when (value) {
Timestamp.ServerTimestamp -> FieldValue.serverTimestamp.nativeValue
is Timestamp -> value.nativeValue
else -> throw SerializationException("Cannot serialize $value")
}
},
fromNativeValue = { value ->
when (value) {
is NativeTimestamp -> Timestamp(value)
FieldValue.serverTimestamp.nativeValue -> Timestamp.ServerTimestamp
else -> throw SerializationException("Cannot deserialize $value")
}
},
)
/** A serializer for [Timestamp]. Must be used with [FirebaseEncoder]/[FirebaseDecoder]. */
public object TimestampSerializer : KSerializer<Timestamp> by SpecialValueSerializer(
serialName = "Timestamp",
toNativeValue = Timestamp::nativeValue,
fromNativeValue = { value ->
when (value) {
is NativeTimestamp -> Timestamp(value)
else -> throw SerializationException("Cannot deserialize $value")
}
},
)
/** A serializer for [Timestamp.ServerTimestamp]. Must be used with [FirebaseEncoder]/[FirebaseDecoder]. */
public object ServerTimestampSerializer : KSerializer<Timestamp.ServerTimestamp> by SpecialValueSerializer(
serialName = "Timestamp",
toNativeValue = { FieldValue.serverTimestamp.nativeValue },
fromNativeValue = { value ->
when (value) {
FieldValue.serverTimestamp.nativeValue -> Timestamp.ServerTimestamp
else -> throw SerializationException("Cannot deserialize $value")
}
},
)
/** A serializer for a Double field which is stored as a Timestamp. */
public object DoubleAsTimestampSerializer : KSerializer<Double> by SpecialValueSerializer(
serialName = "Timestamp",
toNativeValue = { value ->
when (value) {
SERVER_TIMESTAMP -> FieldValue.serverTimestamp.nativeValue
else -> Timestamp.fromMilliseconds(value).nativeValue
}
},
fromNativeValue = { value ->
when (value) {
FieldValue.serverTimestamp.nativeValue -> SERVER_TIMESTAMP
is NativeTimestamp -> Timestamp(value).toMilliseconds()
is Double -> value
else -> throw SerializationException("Cannot deserialize $value")
}
},
) {
public const val SERVER_TIMESTAMP: Double = Double.POSITIVE_INFINITY
}
| 83 | Kotlin | 155 | 1,138 | 312beedd23283042277ae6d00393ada87d907589 | 2,856 | firebase-kotlin-sdk | Apache License 2.0 |
app/src/main/java/com/pihrit/photos/screens/common/controllers/BackPressDispatcher.kt | skipadu | 158,967,452 | false | null | package com.pihrit.photos.screens.common.controllers
interface BackPressDispatcher {
fun registerListener(listener: BackPressListener)
fun unregisterListener(listener: BackPressListener)
} | 0 | Kotlin | 0 | 1 | 8a6d1125a70e6d85a751f4bb93ad2f2141e73b79 | 199 | Photos | MIT License |
utils/math/src/main/kotlin/io/bluetape4k/math/integration/AbstractIntegrator.kt | debop | 625,161,599 | false | {"Kotlin": 7504333, "HTML": 502995, "Java": 2273, "JavaScript": 1351, "Shell": 1301, "CSS": 444, "Dockerfile": 121, "Mustache": 82} | package io.bluetape4k.math.integration
import io.bluetape4k.logging.KLogging
import io.bluetape4k.logging.trace
import io.bluetape4k.math.integration.Integrator.Companion.DEFAULT_MAXEVAL
import org.apache.commons.math3.analysis.integration.UnivariateIntegrator
abstract class AbstractIntegrator: Integrator {
companion object: KLogging()
protected abstract val apacheIntegrator: UnivariateIntegrator
override val relativeAccuracy: Double
get() = apacheIntegrator.relativeAccuracy
override val absoluteAccuracy: Double
get() = apacheIntegrator.absoluteAccuracy
/**
* 함수의 [lower, upper) 구간을 적분합니다.
*
* @param evaluator 적분할 함수
* @param lower 시작 위치
* @param upper 끝 위치
* @return 적분 값
*/
override fun integrate(lower: Double, upper: Double, evaluator: (Double) -> Double): Double {
assert(lower <= upper) { "lower[$lower] <= upper[$upper] 이어야 합니다." }
log.trace { "lower=$lower, upper=$upper 범위의 적분을 수행합니다." }
val result = apacheIntegrator.integrate(DEFAULT_MAXEVAL, evaluator, lower, upper)
log.trace { "Integration result=$result" }
return result
}
}
| 0 | Kotlin | 0 | 1 | ce3da5b6bddadd29271303840d334b71db7766d2 | 1,173 | bluetape4k | MIT License |
simplified-bookmarks/src/main/java/org/nypl/simplified/bookmarks/internal/BServiceOpLoadBookmarks.kt | ThePalaceProject | 367,082,997 | false | {"Kotlin": 3272091, "JavaScript": 853788, "Java": 374503, "CSS": 65407, "HTML": 49220, "Shell": 5017, "Ruby": 178} | package org.nypl.simplified.bookmarks.internal
import org.nypl.simplified.accounts.api.AccountID
import org.nypl.simplified.bookmarks.api.BookmarksForBook
import org.nypl.simplified.books.api.BookFormat
import org.nypl.simplified.books.api.BookID
import org.nypl.simplified.books.api.bookmark.BookmarkKind
import org.nypl.simplified.books.api.bookmark.SerializedBookmark
import org.nypl.simplified.books.book_database.api.BookDatabaseEntryFormatHandle.BookDatabaseEntryFormatHandleAudioBook
import org.nypl.simplified.books.book_database.api.BookDatabaseEntryFormatHandle.BookDatabaseEntryFormatHandleEPUB
import org.nypl.simplified.books.book_database.api.BookDatabaseEntryFormatHandle.BookDatabaseEntryFormatHandlePDF
import org.nypl.simplified.profiles.api.ProfileReadableType
import org.slf4j.Logger
/**
* An operation that loads bookmarks.
*/
internal class BServiceOpLoadBookmarks(
logger: Logger,
private val profile: ProfileReadableType,
private val accountID: AccountID,
private val book: BookID
) : BServiceOp<BookmarksForBook>(logger) {
override fun runActual(): BookmarksForBook {
try {
this.logger.debug("[{}]: loading bookmarks for book {}", this.profile.id.uuid, this.book.brief())
val account = this.profile.account(this.accountID)
val books = account.bookDatabase
val entry = books.entry(this.book)
val handle = entry.findFormatHandle(BookDatabaseEntryFormatHandleEPUB::class.java)
?: entry.findFormatHandle(BookDatabaseEntryFormatHandleAudioBook::class.java)
?: entry.findFormatHandle(BookDatabaseEntryFormatHandlePDF::class.java)
if (handle != null) {
val bookmarks: List<SerializedBookmark>
val lastReadLocation: SerializedBookmark?
when (handle.format) {
is BookFormat.BookFormatEPUB -> {
val format = handle.format as BookFormat.BookFormatEPUB
bookmarks = format.bookmarks
lastReadLocation = format.lastReadLocation
}
is BookFormat.BookFormatAudioBook -> {
val format = handle.format as BookFormat.BookFormatAudioBook
bookmarks = format.bookmarks
lastReadLocation = format.lastReadLocation
}
is BookFormat.BookFormatPDF -> {
val format = handle.format as BookFormat.BookFormatPDF
bookmarks = format.bookmarks
lastReadLocation = format.lastReadLocation
}
else -> {
bookmarks = emptyList()
lastReadLocation = null
}
}
this.logger.debug(
"[{}]: loaded {} bookmarks",
this.profile.id.uuid,
bookmarks.size
)
return BookmarksForBook(
bookId = this.book,
lastRead = lastReadLocation,
bookmarks = bookmarks.filter { b -> b.kind == BookmarkKind.BookmarkExplicit }
)
}
} catch (e: Exception) {
this.logger.error("[{}]: error loading bookmarks: ", this.profile.id.uuid, e)
}
this.logger.debug("[{}]: returning empty bookmarks", this.profile.id.uuid)
return BookmarksForBook(this.book, null, listOf())
}
}
| 0 | Kotlin | 4 | 8 | 5e07c7c5f9dfe6c1521cbc6936ca46ec70994da5 | 3,160 | android-core | Apache License 2.0 |
app/src/main/java/com/authsamples/basicmobileapp/views/userinfo/UserInfoFragment.kt | gary-archer | 180,116,783 | false | null | package com.authsamples.basicmobileapp.views.userinfo
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.activityViewModels
import androidx.lifecycle.ViewModelProvider
import com.authsamples.basicmobileapp.R
import com.authsamples.basicmobileapp.app.MainActivityViewModel
import com.authsamples.basicmobileapp.databinding.FragmentUserInfoBinding
import com.authsamples.basicmobileapp.plumbing.errors.UIError
import com.authsamples.basicmobileapp.plumbing.events.NavigatedEvent
import com.authsamples.basicmobileapp.plumbing.events.ReloadUserInfoEvent
import com.authsamples.basicmobileapp.plumbing.events.SetErrorEvent
import org.greenrobot.eventbus.EventBus
import org.greenrobot.eventbus.Subscribe
import org.greenrobot.eventbus.ThreadMode
/*
* The user info fragment renders logged in user details
*/
class UserInfoFragment : androidx.fragment.app.Fragment() {
private lateinit var binding: FragmentUserInfoBinding
/*
* Initialise the view
*/
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View {
// Inflate the view
this.binding = FragmentUserInfoBinding.inflate(inflater, container, false)
// Create our view model using data from the main view model
val mainViewModel: MainActivityViewModel by activityViewModels()
val factory = UserInfoViewModelFactory(
mainViewModel.authenticator,
mainViewModel.apiClient,
mainViewModel.apiViewEvents
)
this.binding.model = ViewModelProvider(this, factory).get(UserInfoViewModel::class.java)
return binding.root
}
/*
* Subscribe to events when the view is created
*/
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
EventBus.getDefault().register(this)
}
/*
* Unsubscribe from events upon exit
*/
override fun onDestroyView() {
super.onDestroyView()
EventBus.getDefault().unregister(this)
}
/*
* Change visibility based on whether showing a main view
*/
@Subscribe(threadMode = ThreadMode.MAIN)
fun onMessageEvent(event: NavigatedEvent) {
if (event.isMainView) {
// Load user info if required after navigating to a main view
this.loadData()
} else {
// When not in a main view we are logged out, so clear user info
this.binding.model!!.clearUserInfo()
// Also ensure that any errors are cleared
val clearEvent = SetErrorEvent(this.getString(R.string.userinfo_error_container), null)
EventBus.getDefault().post(clearEvent)
}
}
/*
* Handle reload events
*/
@Subscribe(threadMode = ThreadMode.MAIN)
fun onMessageEvent(event: ReloadUserInfoEvent) {
this.loadData(true, event.causeError)
}
/*
* When logged in, call the API to get user info for display
*/
private fun loadData(reload: Boolean = false, causeError: Boolean = false) {
// Clear any errors from last time
val clearEvent = SetErrorEvent(this.getString(R.string.userinfo_error_container), null)
EventBus.getDefault().post(clearEvent)
// Render errors on failure
val onError = { uiError: UIError ->
val setEvent = SetErrorEvent(this.getString(R.string.userinfo_error_container), uiError)
EventBus.getDefault().post(setEvent)
}
// Ask the model class to do the work
val options = UserInfoLoadOptions(
reload,
causeError
)
this.binding.model!!.callApi(options, onError)
}
}
| 1 | null | 7 | 31 | 407bbbb27206fb2f4e074c1f6438868bc1460bf8 | 3,859 | oauth.mobilesample.android | MIT License |
app/src/main/java/de/drtobiasprinz/summitbook/ReceiverActivity.kt | prinztob | 370,702,913 | false | {"Kotlin": 889510, "Python": 28063} | package de.drtobiasprinz.summitbook
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.res.ResourcesCompat
import dagger.hilt.android.AndroidEntryPoint
import de.drtobiasprinz.summitbook.SelectOnOsMapActivity.Companion.copyGpxFileToCache
import de.drtobiasprinz.summitbook.databinding.ActivityReceiverBinding
import de.drtobiasprinz.summitbook.models.TrackColor
import de.drtobiasprinz.summitbook.ui.MainActivity
import de.drtobiasprinz.summitbook.ui.dialog.AddSummitDialog
import de.drtobiasprinz.summitbook.ui.utils.OpenStreetMapUtils
import org.osmdroid.config.Configuration
import org.osmdroid.tileprovider.tilesource.TileSourceFactory
import org.osmdroid.util.GeoPoint
import org.osmdroid.views.overlay.Marker
import java.io.File
@AndroidEntryPoint
class ReceiverActivity : AppCompatActivity() {
private var gpxTrackUri: Uri? = null
lateinit var binding: ActivityReceiverBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = ActivityReceiverBinding.inflate(layoutInflater)
setContentView(binding.root)
Log.i("ReceiverActivity", "onCreate")
MainActivity.cache = applicationContext.cacheDir
MainActivity.storage = applicationContext.filesDir
MainActivity.activitiesDir = File(MainActivity.storage, "activities")
binding.osmap.setTileSource(TileSourceFactory.OpenTopo)
Configuration.getInstance().userAgentValue = BuildConfig.APPLICATION_ID
OpenStreetMapUtils.addDefaultSettings(this, binding.osmap, this)
binding.addToSummits.setOnClickListener {
if (gpxTrackUri != null) {
val addSummit = AddSummitDialog()
addSummit.gpxTrackUri = gpxTrackUri
addSummit.fromReceiverActivity = true
addSummit.show(
supportFragmentManager,
getString(R.string.add_new_summit)
)
}
}
binding.addToBookmarks.setOnClickListener {
if (gpxTrackUri != null) {
val addSummit = AddSummitDialog()
addSummit.gpxTrackUri = gpxTrackUri
addSummit.isBookmark = true
addSummit.fromReceiverActivity = true
addSummit.show(
supportFragmentManager,
getString(R.string.add_new_bookmark)
)
}
}
binding.back.setOnClickListener {
finish()
}
}
private fun drawGpxFile(intent: Intent) {
val uri = intent.data
gpxTrackUri = uri
Log.i(
"ReceiverActivity",
"intent was: ${intent.action} , received url ${gpxTrackUri.toString()}"
)
if (uri != null) {
val file = File(MainActivity.cache, "input_filter_file.gpx")
contentResolver.openInputStream(uri)?.use { inputStream ->
copyGpxFileToCache(inputStream, file)
}
if (file.exists()) {
val gpsTrack = SelectOnOsMapActivity.prepareGpxTrack(file.toPath(), null)
gpsTrack?.addGpsTrack(binding.osmap, TrackColor.None)
val highestTrackPoint = gpsTrack?.getHighestElevation()
if (highestTrackPoint != null) {
val highestGeoPoint = GeoPoint(highestTrackPoint.latitude, highestTrackPoint.longitude)
val marker = Marker(binding.osmap)
marker.position = highestGeoPoint
marker.setAnchor(Marker.ANCHOR_CENTER, Marker.ANCHOR_BOTTOM)
marker.icon = ResourcesCompat.getDrawable(
resources,
R.drawable.ic_outline_location_green_48,
null
)
marker.title = "New summit"
}
if (gpsTrack != null) {
binding.osmap.post {
OpenStreetMapUtils.calculateBoundingBox(
binding.osmap,
gpsTrack.trackGeoPoints
)
}
}
}
}
}
override fun onResume() {
super.onResume()
Log.i("ReceiverActivity", "onResume")
if (Intent.ACTION_VIEW == intent.action) {
drawGpxFile(intent)
} else {
Log.i("ReceiverActivity", "intent was something else: ${intent.action}")
}
}
}
| 0 | Kotlin | 0 | 0 | fd0fc69885dfffeef8fe1c92c2e460ea675f6b91 | 4,671 | summitbook | MIT License |
testing/node-driver/src/main/kotlin/net/corda/testing/driver/Driver.kt | varunkm | 105,518,202 | false | null | @file:JvmName("Driver")
package net.corda.testing.driver
import com.google.common.util.concurrent.ThreadFactoryBuilder
import com.typesafe.config.Config
import com.typesafe.config.ConfigRenderOptions
import net.corda.client.rpc.CordaRPCClient
import net.corda.cordform.CordformContext
import net.corda.cordform.CordformNode
import net.corda.cordform.NodeDefinition
import net.corda.core.concurrent.CordaFuture
import net.corda.core.concurrent.firstOf
import net.corda.core.crypto.appendToCommonName
import net.corda.core.crypto.commonName
import net.corda.core.crypto.getX509Name
import net.corda.core.identity.Party
import net.corda.core.internal.ThreadBox
import net.corda.core.internal.concurrent.*
import net.corda.core.internal.div
import net.corda.core.internal.times
import net.corda.core.messaging.CordaRPCOps
import net.corda.core.node.NodeInfo
import net.corda.core.node.services.ServiceInfo
import net.corda.core.node.services.ServiceType
import net.corda.core.utilities.*
import net.corda.node.internal.Node
import net.corda.node.internal.NodeStartup
import net.corda.node.serialization.NodeClock
import net.corda.node.services.config.*
import net.corda.node.services.network.NetworkMapService
import net.corda.node.services.transactions.RaftValidatingNotaryService
import net.corda.node.utilities.ServiceIdentityGenerator
import net.corda.node.utilities.TestClock
import net.corda.nodeapi.ArtemisMessagingComponent
import net.corda.nodeapi.User
import net.corda.nodeapi.config.SSLConfiguration
import net.corda.nodeapi.config.parseAs
import net.corda.nodeapi.internal.addShutdownHook
import net.corda.testing.*
import net.corda.testing.node.MOCK_VERSION_INFO
import okhttp3.OkHttpClient
import okhttp3.Request
import org.bouncycastle.asn1.x500.X500Name
import org.slf4j.Logger
import java.io.File
import java.net.*
import java.nio.file.Path
import java.nio.file.Paths
import java.time.Clock
import java.time.Duration
import java.time.Instant
import java.time.ZoneOffset.UTC
import java.time.format.DateTimeFormatter
import java.util.*
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import java.util.concurrent.ScheduledExecutorService
import java.util.concurrent.TimeUnit.MILLISECONDS
import java.util.concurrent.TimeUnit.SECONDS
import java.util.concurrent.TimeoutException
import java.util.concurrent.atomic.AtomicInteger
import kotlin.concurrent.thread
/**
* This file defines a small "Driver" DSL for starting up nodes that is only intended for development, demos and tests.
*
* The process the driver is run in behaves as an Artemis client and starts up other processes. Namely it first
* bootstraps a network map service to allow the specified nodes to connect to, then starts up the actual nodes.
*
* TODO this file is getting way too big, it should be split into several files.
*/
private val log: Logger = loggerFor<DriverDSL>()
/**
* This is the interface that's exposed to DSL users.
*/
interface DriverDSLExposedInterface : CordformContext {
/**
* Starts a [net.corda.node.internal.Node] in a separate process.
*
* @param providedName Optional name of the node, which will be its legal name in [Party]. Defaults to something
* random. Note that this must be unique as the driver uses it as a primary key!
* @param advertisedServices The set of services to be advertised by the node. Defaults to empty set.
* @param verifierType The type of transaction verifier to use. See: [VerifierType]
* @param rpcUsers List of users who are authorised to use the RPC system. Defaults to empty list.
* @param startInSameProcess Determines if the node should be started inside the same process the Driver is running
* in. If null the Driver-level value will be used.
* @return The [NodeInfo] of the started up node retrieved from the network map service.
*/
fun startNode(providedName: X500Name? = null,
advertisedServices: Set<ServiceInfo> = emptySet(),
rpcUsers: List<User> = emptyList(),
verifierType: VerifierType = VerifierType.InMemory,
customOverrides: Map<String, Any?> = emptyMap(),
startInSameProcess: Boolean? = null): CordaFuture<NodeHandle>
fun startNodes(
nodes: List<CordformNode>,
startInSameProcess: Boolean? = null
): List<CordaFuture<NodeHandle>>
/**
* Starts a distributed notary cluster.
*
* @param notaryName The legal name of the advertised distributed notary service.
* @param clusterSize Number of nodes to create for the cluster.
* @param type The advertised notary service type. Currently the only supported type is [RaftValidatingNotaryService.type].
* @param verifierType The type of transaction verifier to use. See: [VerifierType]
* @param rpcUsers List of users who are authorised to use the RPC system. Defaults to empty list.
* @param startInSameProcess Determines if the node should be started inside the same process the Driver is running
* in. If null the Driver-level value will be used.
* @return The [Party] identity of the distributed notary service, and the [NodeInfo]s of the notaries in the cluster.
*/
fun startNotaryCluster(
notaryName: X500Name,
clusterSize: Int = 3,
type: ServiceType = RaftValidatingNotaryService.type,
verifierType: VerifierType = VerifierType.InMemory,
rpcUsers: List<User> = emptyList(),
startInSameProcess: Boolean? = null): CordaFuture<Pair<Party, List<NodeHandle>>>
/**
* Starts a web server for a node
*
* @param handle The handle for the node that this webserver connects to via RPC.
*/
fun startWebserver(handle: NodeHandle): CordaFuture<WebserverHandle>
/**
* Starts a network map service node. Note that only a single one should ever be running, so you will probably want
* to set networkMapStartStrategy to Dedicated(false) in your [driver] call.
* @param startInProcess Determines if the node should be started inside this process. If null the Driver-level
* value will be used.
*/
fun startDedicatedNetworkMapService(startInProcess: Boolean? = null): CordaFuture<NodeHandle>
fun waitForAllNodesToFinish()
/**
* Polls a function until it returns a non-null value. Note that there is no timeout on the polling.
*
* @param pollName A description of what is being polled.
* @param pollInterval The interval of polling.
* @param warnCount The number of polls after the Driver gives a warning.
* @param check The function being polled.
* @return A future that completes with the non-null value [check] has returned.
*/
fun <A> pollUntilNonNull(pollName: String, pollInterval: Duration = 500.millis, warnCount: Int = 120, check: () -> A?): CordaFuture<A>
/**
* Polls the given function until it returns true.
* @see pollUntilNonNull
*/
fun pollUntilTrue(pollName: String, pollInterval: Duration = 500.millis, warnCount: Int = 120, check: () -> Boolean): CordaFuture<Unit> {
return pollUntilNonNull(pollName, pollInterval, warnCount) { if (check()) Unit else null }
}
val shutdownManager: ShutdownManager
}
interface DriverDSLInternalInterface : DriverDSLExposedInterface {
fun start()
fun shutdown()
}
sealed class NodeHandle {
abstract val nodeInfo: NodeInfo
abstract val rpc: CordaRPCOps
abstract val configuration: FullNodeConfiguration
abstract val webAddress: NetworkHostAndPort
data class OutOfProcess(
override val nodeInfo: NodeInfo,
override val rpc: CordaRPCOps,
override val configuration: FullNodeConfiguration,
override val webAddress: NetworkHostAndPort,
val debugPort: Int?,
val process: Process
) : NodeHandle()
data class InProcess(
override val nodeInfo: NodeInfo,
override val rpc: CordaRPCOps,
override val configuration: FullNodeConfiguration,
override val webAddress: NetworkHostAndPort,
val node: Node,
val nodeThread: Thread
) : NodeHandle()
fun rpcClientToNode(): CordaRPCClient = CordaRPCClient(configuration.rpcAddress!!, initialiseSerialization = false)
}
data class WebserverHandle(
val listenAddress: NetworkHostAndPort,
val process: Process
)
sealed class PortAllocation {
abstract fun nextPort(): Int
fun nextHostAndPort() = NetworkHostAndPort("localhost", nextPort())
class Incremental(startingPort: Int) : PortAllocation() {
val portCounter = AtomicInteger(startingPort)
override fun nextPort() = portCounter.andIncrement
}
object RandomFree : PortAllocation() {
override fun nextPort(): Int {
return ServerSocket().use {
it.bind(InetSocketAddress(0))
it.localPort
}
}
}
}
/**
* [driver] allows one to start up nodes like this:
* driver {
* val noService = startNode(DUMMY_BANK_A.name)
* val notary = startNode(DUMMY_NOTARY.name)
*
* (...)
* }
*
* Note that [DriverDSL.startNode] does not wait for the node to start up synchronously, but rather returns a [CordaFuture]
* of the [NodeInfo] that may be waited on, which completes when the new node registered with the network map service.
*
* The driver implicitly bootstraps a [NetworkMapService].
*
* @param isDebug Indicates whether the spawned nodes should start in jdwt debug mode and have debug level logging.
* @param driverDirectory The base directory node directories go into, defaults to "build/<timestamp>/". The node
* directories themselves are "<baseDirectory>/<legalName>/", where legalName defaults to "<randomName>-<messagingPort>"
* and may be specified in [DriverDSL.startNode].
* @param portAllocation The port allocation strategy to use for the messaging and the web server addresses. Defaults to incremental.
* @param debugPortAllocation The port allocation strategy to use for jvm debugging. Defaults to incremental.
* @param systemProperties A Map of extra system properties which will be given to each new node. Defaults to empty.
* @param useTestClock If true the test clock will be used in Node.
* @param networkMapStartStrategy Determines whether a network map node is started automatically.
* @param startNodesInProcess Provides the default behaviour of whether new nodes should start inside this process or
* not. Note that this may be overridden in [DriverDSLExposedInterface.startNode].
* @param dsl The dsl itself.
* @return The value returned in the [dsl] closure.
*/
@JvmOverloads
fun <A> driver(
isDebug: Boolean = false,
driverDirectory: Path = Paths.get("build", getTimestampAsDirectoryName()),
portAllocation: PortAllocation = PortAllocation.Incremental(10000),
debugPortAllocation: PortAllocation = PortAllocation.Incremental(5005),
systemProperties: Map<String, String> = emptyMap(),
useTestClock: Boolean = false,
initialiseSerialization: Boolean = true,
networkMapStartStrategy: NetworkMapStartStrategy = NetworkMapStartStrategy.Dedicated(startAutomatically = true),
startNodesInProcess: Boolean = false,
dsl: DriverDSLExposedInterface.() -> A
) = genericDriver(
driverDsl = DriverDSL(
portAllocation = portAllocation,
debugPortAllocation = debugPortAllocation,
systemProperties = systemProperties,
driverDirectory = driverDirectory.toAbsolutePath(),
useTestClock = useTestClock,
networkMapStartStrategy = networkMapStartStrategy,
startNodesInProcess = startNodesInProcess,
isDebug = isDebug
),
coerce = { it },
dsl = dsl,
initialiseSerialization = initialiseSerialization
)
/**
* This is a helper method to allow extending of the DSL, along the lines of
* interface SomeOtherExposedDSLInterface : DriverDSLExposedInterface
* interface SomeOtherInternalDSLInterface : DriverDSLInternalInterface, SomeOtherExposedDSLInterface
* class SomeOtherDSL(val driverDSL : DriverDSL) : DriverDSLInternalInterface by driverDSL, SomeOtherInternalDSLInterface
*
* @param coerce We need this explicit coercion witness because we can't put an extra DI : D bound in a `where` clause.
*/
fun <DI : DriverDSLExposedInterface, D : DriverDSLInternalInterface, A> genericDriver(
driverDsl: D,
initialiseSerialization: Boolean = true,
coerce: (D) -> DI,
dsl: DI.() -> A
): A {
if (initialiseSerialization) initialiseTestSerialization()
val shutdownHook = addShutdownHook(driverDsl::shutdown)
try {
driverDsl.start()
return dsl(coerce(driverDsl))
} catch (exception: Throwable) {
log.error("Driver shutting down because of exception", exception)
throw exception
} finally {
driverDsl.shutdown()
shutdownHook.cancel()
if (initialiseSerialization) resetTestSerialization()
}
}
fun getTimestampAsDirectoryName(): String {
return DateTimeFormatter.ofPattern("yyyyMMddHHmmss").withZone(UTC).format(Instant.now())
}
class ListenProcessDeathException(hostAndPort: NetworkHostAndPort, listenProcess: Process) : Exception("The process that was expected to listen on $hostAndPort has died with status: ${listenProcess.exitValue()}")
/**
* @throws ListenProcessDeathException if [listenProcess] dies before the check succeeds, i.e. the check can't succeed as intended.
*/
fun addressMustBeBound(executorService: ScheduledExecutorService, hostAndPort: NetworkHostAndPort, listenProcess: Process? = null) {
addressMustBeBoundFuture(executorService, hostAndPort, listenProcess).getOrThrow()
}
fun addressMustBeBoundFuture(executorService: ScheduledExecutorService, hostAndPort: NetworkHostAndPort, listenProcess: Process? = null): CordaFuture<Unit> {
return poll(executorService, "address $hostAndPort to bind") {
if (listenProcess != null && !listenProcess.isAlive) {
throw ListenProcessDeathException(hostAndPort, listenProcess)
}
try {
Socket(hostAndPort.host, hostAndPort.port).close()
Unit
} catch (_exception: SocketException) {
null
}
}
}
fun addressMustNotBeBound(executorService: ScheduledExecutorService, hostAndPort: NetworkHostAndPort) {
addressMustNotBeBoundFuture(executorService, hostAndPort).getOrThrow()
}
fun addressMustNotBeBoundFuture(executorService: ScheduledExecutorService, hostAndPort: NetworkHostAndPort): CordaFuture<Unit> {
return poll(executorService, "address $hostAndPort to unbind") {
try {
Socket(hostAndPort.host, hostAndPort.port).close()
null
} catch (_exception: SocketException) {
Unit
}
}
}
fun <A> poll(
executorService: ScheduledExecutorService,
pollName: String,
pollInterval: Duration = 500.millis,
warnCount: Int = 120,
check: () -> A?
): CordaFuture<A> {
val resultFuture = openFuture<A>()
val task = object : Runnable {
var counter = -1
override fun run() {
if (resultFuture.isCancelled) return // Give up, caller can no longer get the result.
if (++counter == warnCount) {
log.warn("Been polling $pollName for ${(pollInterval * warnCount.toLong()).seconds} seconds...")
}
try {
val checkResult = check()
if (checkResult != null) {
resultFuture.set(checkResult)
} else {
executorService.schedule(this, pollInterval.toMillis(), MILLISECONDS)
}
} catch (t: Throwable) {
resultFuture.setException(t)
}
}
}
executorService.submit(task) // The check may be expensive, so always run it in the background even the first time.
return resultFuture
}
class ShutdownManager(private val executorService: ExecutorService) {
private class State {
val registeredShutdowns = ArrayList<CordaFuture<() -> Unit>>()
var isShutdown = false
}
private val state = ThreadBox(State())
companion object {
inline fun <A> run(providedExecutorService: ExecutorService? = null, block: ShutdownManager.() -> A): A {
val executorService = providedExecutorService ?: Executors.newScheduledThreadPool(1)
val shutdownManager = ShutdownManager(executorService)
try {
return block(shutdownManager)
} finally {
shutdownManager.shutdown()
providedExecutorService ?: executorService.shutdown()
}
}
}
fun shutdown() {
val shutdownActionFutures = state.locked {
if (isShutdown) {
emptyList<CordaFuture<() -> Unit>>()
} else {
isShutdown = true
registeredShutdowns
}
}
val shutdowns = shutdownActionFutures.map { Try.on { it.getOrThrow(1.seconds) } }
shutdowns.reversed().forEach { when (it) {
is Try.Success ->
try {
it.value()
} catch (t: Throwable) {
log.warn("Exception while shutting down", t)
}
is Try.Failure -> log.warn("Exception while getting shutdown method, disregarding", it.exception)
} }
}
fun registerShutdown(shutdown: CordaFuture<() -> Unit>) {
state.locked {
require(!isShutdown)
registeredShutdowns.add(shutdown)
}
}
fun registerShutdown(shutdown: () -> Unit) = registerShutdown(doneFuture(shutdown))
fun registerProcessShutdown(processFuture: CordaFuture<Process>) {
val processShutdown = processFuture.map { process ->
{
process.destroy()
/** Wait 5 seconds, then [Process.destroyForcibly] */
val finishedFuture = executorService.submit {
process.waitFor()
}
try {
finishedFuture.get(5, SECONDS)
} catch (exception: TimeoutException) {
finishedFuture.cancel(true)
process.destroyForcibly()
}
Unit
}
}
registerShutdown(processShutdown)
}
interface Follower {
fun unfollow()
fun shutdown()
}
fun follower() = object : Follower {
private val start = state.locked { registeredShutdowns.size }
private val end = AtomicInteger(start - 1)
override fun unfollow() = end.set(state.locked { registeredShutdowns.size })
override fun shutdown() = end.get().let { end ->
start > end && throw IllegalStateException("You haven't called unfollow.")
state.locked {
registeredShutdowns.subList(start, end).listIterator(end - start).run {
while (hasPrevious()) {
previous().getOrThrow().invoke()
set(doneFuture {}) // Don't break other followers by doing a remove.
}
}
}
}
}
}
class DriverDSL(
val portAllocation: PortAllocation,
val debugPortAllocation: PortAllocation,
val systemProperties: Map<String, String>,
val driverDirectory: Path,
val useTestClock: Boolean,
val isDebug: Boolean,
val networkMapStartStrategy: NetworkMapStartStrategy,
val startNodesInProcess: Boolean
) : DriverDSLInternalInterface {
private val dedicatedNetworkMapAddress = portAllocation.nextHostAndPort()
private var _executorService: ScheduledExecutorService? = null
val executorService get() = _executorService!!
private var _shutdownManager: ShutdownManager? = null
override val shutdownManager get() = _shutdownManager!!
private val callerPackage = getCallerPackage()
class State {
val processes = ArrayList<CordaFuture<Process>>()
}
private val state = ThreadBox(State())
//TODO: remove this once we can bundle quasar properly.
private val quasarJarPath: String by lazy {
val cl = ClassLoader.getSystemClassLoader()
val urls = (cl as URLClassLoader).urLs
val quasarPattern = ".*quasar.*\\.jar$".toRegex()
val quasarFileUrl = urls.first { quasarPattern.matches(it.path) }
Paths.get(quasarFileUrl.toURI()).toString()
}
fun registerProcess(process: CordaFuture<Process>) {
shutdownManager.registerProcessShutdown(process)
state.locked {
processes.add(process)
}
}
override fun waitForAllNodesToFinish() = state.locked {
processes.transpose().get().forEach {
it.waitFor()
}
}
override fun shutdown() {
_shutdownManager?.shutdown()
_executorService?.shutdownNow()
}
private fun establishRpc(nodeAddress: NetworkHostAndPort, sslConfig: SSLConfiguration, processDeathFuture: CordaFuture<out Process>): CordaFuture<CordaRPCOps> {
val client = CordaRPCClient(nodeAddress, sslConfig, initialiseSerialization = false)
val connectionFuture = poll(executorService, "RPC connection") {
try {
client.start(ArtemisMessagingComponent.NODE_USER, ArtemisMessagingComponent.NODE_USER)
} catch (e: Exception) {
if (processDeathFuture.isDone) throw e
log.error("Exception $e, Retrying RPC connection at $nodeAddress")
null
}
}
return firstOf(connectionFuture, processDeathFuture) {
if (it == processDeathFuture) {
throw ListenProcessDeathException(nodeAddress, processDeathFuture.getOrThrow())
}
val connection = connectionFuture.getOrThrow()
shutdownManager.registerShutdown(connection::close)
connection.proxy
}
}
private fun networkMapServiceConfigLookup(networkMapCandidates: List<NodeDefinition>): (X500Name) -> Map<String, String>? {
return networkMapStartStrategy.run {
when (this) {
is NetworkMapStartStrategy.Dedicated -> {
serviceConfig(dedicatedNetworkMapAddress).let {
{ _: X500Name -> it }
}
}
is NetworkMapStartStrategy.Nominated -> {
serviceConfig(networkMapCandidates.filter {
it.name == legalName.toString()
}.single().config.getString("p2pAddress").parseNetworkHostAndPort()).let {
{ nodeName: X500Name -> if (nodeName == legalName) null else it }
}
}
}
}
}
override fun startNode(
providedName: X500Name?,
advertisedServices: Set<ServiceInfo>,
rpcUsers: List<User>,
verifierType: VerifierType,
customOverrides: Map<String, Any?>,
startInSameProcess: Boolean?
): CordaFuture<NodeHandle> {
val p2pAddress = portAllocation.nextHostAndPort()
val rpcAddress = portAllocation.nextHostAndPort()
val webAddress = portAllocation.nextHostAndPort()
// TODO: Derive name from the full picked name, don't just wrap the common name
val name = providedName ?: getX509Name("${oneOf(names).commonName}-${p2pAddress.port}", "London", "<EMAIL>", null)
val networkMapServiceConfigLookup = networkMapServiceConfigLookup(listOf(object : NodeDefinition {
override fun getName() = name.toString()
override fun getConfig() = configOf("p2pAddress" to p2pAddress.toString())
}))
val config = ConfigHelper.loadConfig(
baseDirectory = baseDirectory(name),
allowMissingConfig = true,
configOverrides = configOf(
"myLegalName" to name.toString(),
"p2pAddress" to p2pAddress.toString(),
"rpcAddress" to rpcAddress.toString(),
"webAddress" to webAddress.toString(),
"extraAdvertisedServiceIds" to advertisedServices.map { it.toString() },
"networkMapService" to networkMapServiceConfigLookup(name),
"useTestClock" to useTestClock,
"rpcUsers" to rpcUsers.map { it.toMap() },
"verifierType" to verifierType.name
) + customOverrides
)
return startNodeInternal(config, webAddress, startInSameProcess)
}
override fun startNodes(nodes: List<CordformNode>, startInSameProcess: Boolean?): List<CordaFuture<NodeHandle>> {
val networkMapServiceConfigLookup = networkMapServiceConfigLookup(nodes)
return nodes.map { node ->
portAllocation.nextHostAndPort() // rpcAddress
val webAddress = portAllocation.nextHostAndPort()
val name = X500Name(node.name)
val config = ConfigHelper.loadConfig(
baseDirectory = baseDirectory(name),
allowMissingConfig = true,
configOverrides = node.config + mapOf(
"extraAdvertisedServiceIds" to node.advertisedServices,
"networkMapService" to networkMapServiceConfigLookup(name),
"rpcUsers" to node.rpcUsers,
"notaryClusterAddresses" to node.notaryClusterAddresses
)
)
startNodeInternal(config, webAddress, startInSameProcess)
}
}
override fun startNotaryCluster(
notaryName: X500Name,
clusterSize: Int,
type: ServiceType,
verifierType: VerifierType,
rpcUsers: List<User>,
startInSameProcess: Boolean?
): CordaFuture<Pair<Party, List<NodeHandle>>> {
val nodeNames = (0 until clusterSize).map { DUMMY_NOTARY.name.appendToCommonName(" $it") }
val paths = nodeNames.map { baseDirectory(it) }
ServiceIdentityGenerator.generateToDisk(paths, type.id, notaryName)
val advertisedServices = setOf(ServiceInfo(type, notaryName))
val notaryClusterAddress = portAllocation.nextHostAndPort()
// Start the first node that will bootstrap the cluster
val firstNotaryFuture = startNode(
providedName = nodeNames.first(),
advertisedServices = advertisedServices,
rpcUsers = rpcUsers,
verifierType = verifierType,
customOverrides = mapOf("notaryNodeAddress" to notaryClusterAddress.toString()),
startInSameProcess = startInSameProcess
)
// All other nodes will join the cluster
val restNotaryFutures = nodeNames.drop(1).map {
val nodeAddress = portAllocation.nextHostAndPort()
val configOverride = mapOf("notaryNodeAddress" to nodeAddress.toString(), "notaryClusterAddresses" to listOf(notaryClusterAddress.toString()))
startNode(it, advertisedServices, rpcUsers, verifierType, configOverride)
}
return firstNotaryFuture.flatMap { firstNotary ->
val notaryParty = firstNotary.nodeInfo.notaryIdentity
restNotaryFutures.transpose().map { restNotaries ->
Pair(notaryParty, listOf(firstNotary) + restNotaries)
}
}
}
private fun queryWebserver(handle: NodeHandle, process: Process): WebserverHandle {
val protocol = if (handle.configuration.useHTTPS) "https://" else "http://"
val url = URL("$protocol${handle.webAddress}/api/status")
val client = OkHttpClient.Builder().connectTimeout(5, SECONDS).readTimeout(60, SECONDS).build()
while (process.isAlive) try {
val response = client.newCall(Request.Builder().url(url).build()).execute()
if (response.isSuccessful && (response.body().string() == "started")) {
return WebserverHandle(handle.webAddress, process)
}
} catch(e: ConnectException) {
log.debug("Retrying webserver info at ${handle.webAddress}")
}
throw IllegalStateException("Webserver at ${handle.webAddress} has died")
}
override fun startWebserver(handle: NodeHandle): CordaFuture<WebserverHandle> {
val debugPort = if (isDebug) debugPortAllocation.nextPort() else null
val processFuture = DriverDSL.startWebserver(executorService, handle, debugPort)
registerProcess(processFuture)
return processFuture.map { queryWebserver(handle, it) }
}
override fun start() {
_executorService = Executors.newScheduledThreadPool(2, ThreadFactoryBuilder().setNameFormat("driver-pool-thread-%d").build())
_shutdownManager = ShutdownManager(executorService)
// We set this property so that in-process nodes find cordapps. Out-of-process nodes need this passed in when started.
System.setProperty("net.corda.node.cordapp.scan.package", callerPackage)
if (networkMapStartStrategy.startDedicated) {
startDedicatedNetworkMapService().andForget(log) // Allow it to start concurrently with other nodes.
}
}
override fun baseDirectory(nodeName: X500Name): Path = driverDirectory / nodeName.commonName.replace(WHITESPACE, "")
override fun startDedicatedNetworkMapService(startInProcess: Boolean?): CordaFuture<NodeHandle> {
val webAddress = portAllocation.nextHostAndPort()
val networkMapLegalName = networkMapStartStrategy.legalName
val config = ConfigHelper.loadConfig(
baseDirectory = baseDirectory(networkMapLegalName),
allowMissingConfig = true,
configOverrides = configOf(
"myLegalName" to networkMapLegalName.toString(),
// TODO: remove the webAddress as NMS doesn't need to run a web server. This will cause all
// node port numbers to be shifted, so all demos and docs need to be updated accordingly.
"webAddress" to webAddress.toString(),
"p2pAddress" to dedicatedNetworkMapAddress.toString(),
"useTestClock" to useTestClock
)
)
return startNodeInternal(config, webAddress, startInProcess)
}
private fun startNodeInternal(config: Config, webAddress: NetworkHostAndPort, startInProcess: Boolean?): CordaFuture<NodeHandle> {
val nodeConfiguration = config.parseAs<FullNodeConfiguration>()
if (startInProcess ?: startNodesInProcess) {
val nodeAndThreadFuture = startInProcessNode(executorService, nodeConfiguration, config)
shutdownManager.registerShutdown(
nodeAndThreadFuture.map { (node, thread) -> {
node.stop()
thread.interrupt()
} }
)
return nodeAndThreadFuture.flatMap { (node, thread) ->
establishRpc(nodeConfiguration.p2pAddress, nodeConfiguration, openFuture()).flatMap { rpc ->
rpc.waitUntilRegisteredWithNetworkMap().map {
NodeHandle.InProcess(rpc.nodeIdentity(), rpc, nodeConfiguration, webAddress, node, thread)
}
}
}
} else {
val debugPort = if (isDebug) debugPortAllocation.nextPort() else null
val processFuture = startOutOfProcessNode(executorService, nodeConfiguration, config, quasarJarPath, debugPort, systemProperties, callerPackage)
registerProcess(processFuture)
return processFuture.flatMap { process ->
val processDeathFuture = poll(executorService, "process death") {
if (process.isAlive) null else process
}
// We continue to use SSL enabled port for RPC when its for node user.
establishRpc(nodeConfiguration.p2pAddress, nodeConfiguration, processDeathFuture).flatMap { rpc ->
// Call waitUntilRegisteredWithNetworkMap in background in case RPC is failing over:
val networkMapFuture = executorService.fork {
rpc.waitUntilRegisteredWithNetworkMap()
}.flatMap { it }
firstOf(processDeathFuture, networkMapFuture) {
if (it == processDeathFuture) {
throw ListenProcessDeathException(nodeConfiguration.p2pAddress, process)
}
processDeathFuture.cancel(false)
NodeHandle.OutOfProcess(rpc.nodeIdentity(), rpc, nodeConfiguration, webAddress, debugPort, process)
}
}
}
}
}
override fun <A> pollUntilNonNull(pollName: String, pollInterval: Duration, warnCount: Int, check: () -> A?): CordaFuture<A> {
val pollFuture = poll(executorService, pollName, pollInterval, warnCount, check)
shutdownManager.registerShutdown { pollFuture.cancel(true) }
return pollFuture
}
companion object {
private val names = arrayOf(
ALICE.name,
BOB.name,
DUMMY_BANK_A.name
)
private fun <A> oneOf(array: Array<A>) = array[Random().nextInt(array.size)]
private fun startInProcessNode(
executorService: ScheduledExecutorService,
nodeConf: FullNodeConfiguration,
config: Config
): CordaFuture<Pair<Node, Thread>> {
return executorService.fork {
log.info("Starting in-process Node ${nodeConf.myLegalName.commonName}")
// Write node.conf
writeConfig(nodeConf.baseDirectory, "node.conf", config)
// TODO pass the version in?
val node = Node(nodeConf, nodeConf.calculateServices(), MOCK_VERSION_INFO, initialiseSerialization = false)
node.start()
val nodeThread = thread(name = nodeConf.myLegalName.commonName) {
node.run()
}
node to nodeThread
}.flatMap { nodeAndThread -> addressMustBeBoundFuture(executorService, nodeConf.p2pAddress).map { nodeAndThread } }
}
private fun startOutOfProcessNode(
executorService: ScheduledExecutorService,
nodeConf: FullNodeConfiguration,
config: Config,
quasarJarPath: String,
debugPort: Int?,
overriddenSystemProperties: Map<String, String>,
callerPackage: String
): CordaFuture<Process> {
val processFuture = executorService.fork {
log.info("Starting out-of-process Node ${nodeConf.myLegalName.commonName}")
// Write node.conf
writeConfig(nodeConf.baseDirectory, "node.conf", config)
val systemProperties = overriddenSystemProperties + mapOf(
"name" to nodeConf.myLegalName,
"visualvm.display.name" to "corda-${nodeConf.myLegalName}",
"net.corda.node.cordapp.scan.package" to callerPackage,
"java.io.tmpdir" to System.getProperty("java.io.tmpdir") // Inherit from parent process
)
// TODO Add this once we upgrade to quasar 0.7.8, this causes startup time to halve.
// val excludePattern = x(rx**;io**;kotlin**;jdk**;reflectasm**;groovyjarjarasm**;groovy**;joptsimple**;groovyjarjarantlr**;javassist**;com.fasterxml**;com.typesafe**;com.google**;com.zaxxer**;com.jcabi**;com.codahale**;com.esotericsoftware**;de.javakaffee**;org.objectweb**;org.slf4j**;org.w3c**;org.codehaus**;org.h2**;org.crsh**;org.fusesource**;org.hibernate**;org.dom4j**;org.bouncycastle**;org.apache**;org.objenesis**;org.jboss**;org.xml**;org.jcp**;org.jetbrains**;org.yaml**;co.paralleluniverse**;net.i2p**)"
// val extraJvmArguments = systemProperties.map { "-D${it.key}=${it.value}" } +
// "-javaagent:$quasarJarPath=$excludePattern"
val extraJvmArguments = systemProperties.map { "-D${it.key}=${it.value}" } +
"-javaagent:$quasarJarPath"
val loggingLevel = if (debugPort == null) "INFO" else "DEBUG"
ProcessUtilities.startCordaProcess(
className = "net.corda.node.Corda", // cannot directly get class for this, so just use string
arguments = listOf(
"--base-directory=${nodeConf.baseDirectory}",
"--logging-level=$loggingLevel",
"--no-local-shell"
),
jdwpPort = debugPort,
extraJvmArguments = extraJvmArguments,
errorLogPath = nodeConf.baseDirectory / NodeStartup.LOGS_DIRECTORY_NAME / "error.log",
workingDirectory = nodeConf.baseDirectory
)
}
return processFuture.flatMap {
process -> addressMustBeBoundFuture(executorService, nodeConf.p2pAddress, process).map { process }
}
}
private fun startWebserver(
executorService: ScheduledExecutorService,
handle: NodeHandle,
debugPort: Int?
): CordaFuture<Process> {
return executorService.fork {
val className = "net.corda.webserver.WebServer"
ProcessUtilities.startCordaProcess(
className = className, // cannot directly get class for this, so just use string
arguments = listOf("--base-directory", handle.configuration.baseDirectory.toString()),
jdwpPort = debugPort,
extraJvmArguments = listOf(
"-Dname=node-${handle.configuration.p2pAddress}-webserver",
"-Djava.io.tmpdir=${System.getProperty("java.io.tmpdir")}" // Inherit from parent process
),
errorLogPath = Paths.get("error.$className.log")
)
}.flatMap { process -> addressMustBeBoundFuture(executorService, handle.webAddress, process).map { process } }
}
private fun getCallerPackage(): String {
return Exception()
.stackTrace
.first { it.fileName != "Driver.kt" }
.let { Class.forName(it.className).`package`.name }
}
}
}
fun writeConfig(path: Path, filename: String, config: Config) {
path.toFile().mkdirs()
File("$path/$filename").writeText(config.root().render(ConfigRenderOptions.defaults()))
}
| 11 | null | 1 | 1 | f9614123968035cb325c6de0b84cf2718643f399 | 39,600 | corda | Apache License 2.0 |
CommonRecycler-Kotlin/src/main/java/com/shuyu/commonrecycler/xrecycler/ArrowRefreshHeader.kt | CarGuo | 74,585,853 | false | null | package com.shuyu.commonrecycler.xrecycler
import android.animation.ValueAnimator
import android.content.Context
import android.os.Handler
import android.util.AttributeSet
import android.view.Gravity
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.view.animation.Animation
import android.view.animation.RotateAnimation
import android.widget.ImageView
import android.widget.LinearLayout
import android.widget.ProgressBar
import android.widget.TextView
import com.shuyu.commonrecycler.R
import com.shuyu.commonrecycler.xrecycler.base.BaseRefreshHeader
import com.shuyu.commonrecycler.xrecycler.other.ProgressStyle
import com.shuyu.commonrecycler.xrecycler.other.SimpleViewSwitcher
import com.shuyu.commonrecycler.xrecycler.progressindicator.AVLoadingIndicatorView
import java.util.Date
open class ArrowRefreshHeader : BaseRefreshHeader {
private var mContainer: LinearLayout? = null
private var mArrowImageView: ImageView? = null
private var mProgressBar: SimpleViewSwitcher? = null
private var mStatusTextView: TextView? = null
private var mHeaderTimeView: TextView? = null
private var mRotateUpAnim: Animation? = null
private var mRotateDownAnim: Animation? = null
override// 显示进度
// 显示箭头图片
var state = BaseRefreshHeader.STATE_NORMAL
set(state) {
if (state == this.state) return
when (state) {
BaseRefreshHeader.STATE_REFRESHING -> {
mArrowImageView?.clearAnimation()
mArrowImageView?.visibility = View.INVISIBLE
mProgressBar?.visibility = View.VISIBLE
}
BaseRefreshHeader.STATE_DONE -> {
mArrowImageView?.visibility = View.INVISIBLE
mProgressBar?.visibility = View.INVISIBLE
}
else -> {
mArrowImageView?.visibility = View.VISIBLE
mProgressBar?.visibility = View.INVISIBLE
}
}
when (state) {
BaseRefreshHeader.STATE_NORMAL -> {
if (this.state == BaseRefreshHeader.STATE_RELEASE_TO_REFRESH) {
mArrowImageView?.startAnimation(mRotateDownAnim)
}
if (this.state == BaseRefreshHeader.STATE_REFRESHING) {
mArrowImageView?.clearAnimation()
}
mStatusTextView?.setText(R.string.listview_header_hint_normal)
}
BaseRefreshHeader.STATE_RELEASE_TO_REFRESH -> if (this.state != BaseRefreshHeader.STATE_RELEASE_TO_REFRESH) {
mArrowImageView?.clearAnimation()
mArrowImageView?.startAnimation(mRotateUpAnim)
mStatusTextView?.setText(R.string.listview_header_hint_release)
}
BaseRefreshHeader.STATE_REFRESHING -> mStatusTextView?.setText(R.string.refreshing)
BaseRefreshHeader.STATE_DONE -> mStatusTextView?.setText(R.string.refresh_done)
}
field = state
}
var mMeasuredHeight: Int = 0
override var visibleHeight: Int
get() {
val lp = mContainer?.layoutParams as LinearLayout.LayoutParams
return lp.height
}
set(heightT) {
var height = heightT
if (height < 0) height = 0
val lp = mContainer?.layoutParams as LinearLayout.LayoutParams
lp.height = height
mContainer?.layoutParams = lp
}
constructor(context: Context) : super(context) {
initView()
}
/**
* @param context
* @param attrs
*/
constructor(context: Context, attrs: AttributeSet) : super(context, attrs) {
initView()
}
private fun initView() {
// 初始情况，设置下拉刷新view高度为0
mContainer = LayoutInflater.from(context).inflate(
R.layout.listview_header, null) as LinearLayout
val lp = LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT)
lp.setMargins(0, 0, 0, 0)
this.layoutParams = lp
this.setPadding(0, 0, 0, 0)
addView(mContainer, LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, 0))
setGravity(Gravity.BOTTOM)
mArrowImageView = findViewById(R.id.listview_header_arrow) as ImageView
mStatusTextView = findViewById(R.id.refresh_status_textview) as TextView
//init the progress view
mProgressBar = findViewById(R.id.listview_header_progressbar) as SimpleViewSwitcher
val progressView = AVLoadingIndicatorView(context)
progressView.setIndicatorColor(-0x4a4a4b)
progressView.setIndicatorId(ProgressStyle.BallSpinFadeLoader)
mProgressBar?.setView(progressView)
mRotateUpAnim = RotateAnimation(0.0f, -180.0f,
Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f)
mRotateUpAnim?.duration = ROTATE_ANIM_DURATION.toLong()
mRotateUpAnim?.fillAfter = true
mRotateDownAnim = RotateAnimation(-180.0f, 0.0f,
Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF, 0.5f)
mRotateDownAnim?.duration = ROTATE_ANIM_DURATION.toLong()
mRotateDownAnim?.fillAfter = true
mHeaderTimeView = findViewById(R.id.last_refresh_time) as TextView
measure(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT)
mMeasuredHeight = measuredHeight
}
override fun setProgressStyle(style: Int) {
if (style == ProgressStyle.SysProgress) {
mProgressBar?.setView(ProgressBar(context, null, android.R.attr.progressBarStyle))
} else {
val progressView = AVLoadingIndicatorView(this.context)
progressView.setIndicatorColor(-0x4a4a4b)
progressView.setIndicatorId(style)
mProgressBar?.setView(progressView)
}
}
override fun setArrowImageView(resid: Int) {
mArrowImageView?.setImageResource(resid)
}
override fun refreshComplete() {
mHeaderTimeView?.text = friendlyTime(Date())
state = BaseRefreshHeader.STATE_DONE
Handler().postDelayed({ reset() }, 200)
}
override fun onMove(delta: Float) {
if (visibleHeight > 0 || delta > 0) {
visibleHeight += delta.toInt()
if (state <= BaseRefreshHeader.STATE_RELEASE_TO_REFRESH) { // 未处于刷新状态，更新箭头
state = if (visibleHeight > mMeasuredHeight) {
BaseRefreshHeader.STATE_RELEASE_TO_REFRESH
} else {
BaseRefreshHeader.STATE_NORMAL
}
}
}
}
override fun releaseAction(): Boolean {
var isOnRefresh = false
val height = visibleHeight
if (height == 0)
// not visible.
isOnRefresh = false
if (visibleHeight > mMeasuredHeight && state < BaseRefreshHeader.STATE_REFRESHING) {
state = BaseRefreshHeader.STATE_REFRESHING
isOnRefresh = true
}
// refreshing and header isn't shown fully. do nothing.
if (state == BaseRefreshHeader.STATE_REFRESHING && height <= mMeasuredHeight) {
//return;
}
var destHeight = 0 // default: scroll back to dismiss header.
// is refreshing, just scroll back to show all the header.
if (state == BaseRefreshHeader.STATE_REFRESHING) {
destHeight = mMeasuredHeight
}
smoothScrollTo(destHeight)
return isOnRefresh
}
override fun reset() {
smoothScrollTo(0)
Handler().postDelayed({ state = BaseRefreshHeader.STATE_NORMAL }, 500)
}
private fun smoothScrollTo(destHeight: Int) {
val animator = ValueAnimator.ofInt(visibleHeight, destHeight)
animator.setDuration(300).start()
animator.addUpdateListener { animation -> visibleHeight = animation.animatedValue as Int }
animator.start()
}
companion object {
private val ROTATE_ANIM_DURATION = 180
fun friendlyTime(time: Date): String {
//获取time距离当前的秒数
val ct = ((System.currentTimeMillis() - time.time) / 1000).toInt()
if (ct == 0) {
return "刚刚"
}
if (ct in 1..59) {
return ct.toString() + "秒前"
}
if (ct in 60..3599) {
return Math.max(ct / 60, 1).toString() + "分钟前"
}
if (ct in 3600..86399)
return (ct / 3600).toString() + "小时前"
if (ct in 86400..2591999) { //86400 * 30
val day = ct / 86400
return day.toString() + "天前"
}
return if (ct in 2592000..31103999) { //86400 * 30
(ct / 2592000).toString() + "月前"
} else (ct / 31104000).toString() + "年前"
}
}
} | 1 | null | 61 | 260 | c759af9544aa025a7ab15991f6b3c5fabc3b3f68 | 9,086 | LazyRecyclerAdapter | MIT License |
feature/feed/domain/api/src/main/kotlin/com/savvasdalkitsis/uhuruphotos/feature/feed/domain/api/worker/FeedWorkScheduler.kt | savvasdalkitsis | 485,908,521 | false | null | package com.savvasdalkitsis.uhuruphotos.feature.feed.domain.api.worker
import androidx.work.ExistingPeriodicWorkPolicy
import androidx.work.WorkInfo
import kotlinx.coroutines.flow.Flow
interface FeedWorkScheduler {
fun scheduleFeedRefreshNow(shallow: Boolean)
fun scheduleFeedRefreshPeriodic(
existingPeriodicWorkPolicy: ExistingPeriodicWorkPolicy
)
fun schedulePrecacheThumbnailsNow()
fun observeFeedRefreshJob(): Flow<RefreshJobState?>
fun observeFeedRefreshJobStatus(): Flow<WorkInfo.State?>
fun cancelFullFeedSync()
fun observePrecacheThumbnailsJob(): Flow<RefreshJobState?>
fun observePrecacheThumbnailsJobStatus(): Flow<WorkInfo.State?>
fun cancelPrecacheThumbnails()
} | 49 | Kotlin | 13 | 228 | f43ba3fa89429aeadd8e2a8de7f14b628e62f228 | 726 | uhuruphotos-android | Apache License 2.0 |
Projects/Test/app/src/main/java/ademar/study/test/view/detail/DetailActivity.kt | ademar111190 | 76,153,266 | false | null | package ademar.study.test.view.detail
import ademar.study.test.R
import ademar.study.test.navigation.FlowController
import ademar.study.test.view.base.BaseActivity
import android.os.Bundle
import javax.inject.Inject
class DetailActivity : BaseActivity() {
@Inject lateinit var flowController: FlowController
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.detail_activity)
prepareTaskDescription()
component.inject(this)
flowController.launchDetail(this)
}
}
| 0 | Kotlin | 1 | 1 | 65466ea1c6e4f75ae9791826a428c7dd8e101f98 | 580 | Studies | MIT License |
kotlin-for-gophers/nullreceiver.kt | willmadison | 70,343,002 | false | {"Go": 10333, "Java": 9178, "Kotlin": 4631} | data class Node(val value: Int, val left: Node? = null, val right: Node? = null)
fun Node?.Sum(): Int = when(this) {
null -> 0
else -> this.value + this.left.Sum() + this.right.Sum()
}
fun main(args: Array<String>) {
val tree = Node(1, right = Node(9))
println(tree.Sum()) // 10
} | 0 | Go | 0 | 1 | 558ec17a47af5aa9747054758d1c7344729c9ebb | 298 | presentations | MIT License |
praytimes/src/main/kotlin/com/typ/islamictkt/utils/AstronomyUtils.kt | typ-AhmedSleem | 669,187,995 | false | null | package com.typ.islamictkt.prays.utils
import com.typ.islamictkt.datetime.Timestamp
import com.typ.islamictkt.datetime.YMD
import com.typ.islamictkt.prays.enums.HigherLatitudeMethod
import kotlin.math.floor
object AstronomyUtils {
/**
* Range reduce hours to 0..23
*/
fun fixHour(a: Double): Double {
var temp = a
temp -= 24.0 * floor(temp / 24.0)
temp = if (temp < 0) temp + 24 else temp
return temp
}
/** Calculate julian date from a calendar date */
fun calculateJulianDate(ymd: YMD): Double {
var tYear = ymd.years
var tMonth = ymd.months
if (tMonth <= 2) {
tYear -= 1
tMonth += 12
}
val A = floor(tYear / 100.0)
val B = 2 - A + floor(A / 4.0)
return floor(365.25 * (tYear + 4716)) + floor(30.6001 * (tMonth + 1)) + ymd.days + B - 1524.5
}
/** Convert a calendar date to julian date (second method) */
fun calcJD(year: Int, month: Int, day: Int): Double {
val j1970 = 2440588.0
val date = Timestamp(year, month - 1, day)
val days = floor(date.toMillis().toDouble() / (1000.0 * 60.0 * 60.0 * 24.0))
return j1970 + days - 0.5
}
/** References:
* http://www.ummah.net/astronomy/saltime
* http://aa.usno.navy.mil/faq/docs/SunApprox.html
* Compute declination angle of sun and equation of time */
private fun calculateSunPosition(jd: Double): DoubleArray {
val D = jd - 2451545
val g = PrayerTimesMath.finAngle(357.529 + 0.98560028 * D)
val q = PrayerTimesMath.finAngle(280.459 + 0.98564736 * D)
val L = PrayerTimesMath.finAngle(q + 1.915 * PrayerTimesMath.dSin(g) + 0.020 * PrayerTimesMath.dSin(2 * g))
// double R = 1.00014 - 0.01671 * [self dcos:g] - 0.00014 * [self dcos:(2*g)];
val e = 23.439 - 0.00000036 * D
val d = PrayerTimesMath.dArcSin(PrayerTimesMath.dSin(e) * PrayerTimesMath.dSin(L))
var RA = PrayerTimesMath.dArcTan2(PrayerTimesMath.dCos(e) * PrayerTimesMath.dSin(L), PrayerTimesMath.dCos(L)) / 15.0
RA = fixHour(RA)
val equOfTime = q / 15.0 - RA
val sPosition = DoubleArray(2)
sPosition[0] = d
sPosition[1] = equOfTime
return sPosition
}
/** Compute declination angle of sun */
fun calculateSunDeclination(jd: Double): Double = calculateSunPosition(jd)[0]
/** Compute equation of time */
private fun calculateEquOfTime(jd: Double): Double = calculateSunPosition(jd)[1]
/** Compute mid-day (Dhuhr, Zawal) time */
fun calculateMidDay(jDate: Double, t: Double): Double {
val eot = calculateEquOfTime(jDate + t)
return fixHour(12 - eot)
}
/** The night portion used for adjusting times in higher latitudes */
fun calculateNightPortion(method: HigherLatitudeMethod, angle: Double): Double {
return when {
method === HigherLatitudeMethod.ANGLEBASED -> angle / 60.0
method === HigherLatitudeMethod.MIDNIGHT -> 0.5
method === HigherLatitudeMethod.ONESEVENTH -> 0.14286
else -> 0.0
}
}
/** Convert hours to day portions */
fun calculateDayPortion(times: DoubleArray): DoubleArray {
for (i in 0..6) times[i] /= 24.0
return times
}
} | 6 | Kotlin | 0 | 1 | c77f2e674280c5f6322d5bb39ab90be969c0dd20 | 3,333 | islamic-toolkit-kt | MIT License |
klocation/src/androidMain/kotlin/com/addhen/klocation/LocationService.kt | addhen | 839,996,776 | false | {"Kotlin": 50463, "Shell": 1491} | // Copyright 2024, Addhen Ltd and the k-location project contributors
// SPDX-License-Identifier: Apache-2.0
package com.addhen.klocation
import android.content.Context
import android.location.Location
import android.location.LocationManager
import kotlinx.coroutines.flow.Flow
/**
* This class provides methods to request for location updates, retrieve the last known location,
* and stop location tracking. It uses a [LocationProvider] to handle the actual location operations.
*
* @param locationProvider The [LocationProvider] used to manage location updates.
* Defaults to [AndroidLocationProvider].
*/
public actual class LocationService(
public actual val locationProvider: LocationProvider,
) {
/**
* Constructs a [LocationService] with the given [context] and [locationProvider].
*
* @param context The Android [Context] to be used to get the [LocationManager] and for
* checking for the necessary required permissions.
* @param locationProvider The [LocationProvider] used to manage location updates.
* Defaults to [AndroidLocationProvider].
*/
public constructor(
context: Context,
locationProvider: LocationProvider = AndroidLocationProvider(context),
) : this(locationProvider)
/**
* requests location updates as a [Flow] of [LocationState].
*
* @return A [Flow] emitting [LocationState] representing location updates or other states.
*/
public actual fun requestLocationUpdates(): Flow<LocationState> {
return locationProvider.requestLocationUpdates()
}
/**
* Retrieves the last known location.
*
* @return A [LocationState] representing the last known location or other states.
*/
public actual suspend fun getLastKnownLocation(): LocationState {
return locationProvider.getLastKnownLocation()
}
/**
* Stops all location update requests.
*
* This method should be called when location updates are no longer needed
* to conserve system resources and battery life.
*/
public actual fun stopRequestingLocationUpdates(): Unit =
locationProvider.stopRequestingLocationUpdates()
}
/**
* Converts a [LocationState.CurrentLocation.libLocation] to a [Location].
*
* @return A [Location] if the [LocationState.CurrentLocation.libLocation] is not null,
* otherwise null.
*/
public val LocationState.CurrentLocation<*>.location: Location?
get() = this.libLocation as? Location
| 0 | Kotlin | 0 | 7 | ac6aac259da9632233fca1afc8c97fe314a45e27 | 2,468 | klocation | Apache License 2.0 |
idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/symbols/KtFirOverrideInfoProvider.kt | BradOselo | 367,097,840 | false | null | /*
* Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.idea.frontend.api.fir.symbols
import org.jetbrains.kotlin.fir.analysis.checkers.getImplementationStatus
import org.jetbrains.kotlin.fir.analysis.checkers.isVisibleInClass
import org.jetbrains.kotlin.fir.containingClass
import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.originalForIntersectionOverrideAttr
import org.jetbrains.kotlin.fir.originalForSubstitutionOverride
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.SessionHolderImpl
import org.jetbrains.kotlin.fir.scopes.impl.delegatedWrapperData
import org.jetbrains.kotlin.idea.frontend.api.KtAnalysisSession
import org.jetbrains.kotlin.idea.frontend.api.components.KtOverrideInfoProvider
import org.jetbrains.kotlin.idea.frontend.api.fir.KtFirAnalysisSession
import org.jetbrains.kotlin.idea.frontend.api.fir.buildSymbol
import org.jetbrains.kotlin.idea.frontend.api.symbols.KtCallableSymbol
import org.jetbrains.kotlin.idea.frontend.api.symbols.KtClassOrObjectSymbol
import org.jetbrains.kotlin.idea.frontend.api.tokens.ValidityToken
import org.jetbrains.kotlin.util.ImplementationStatus
class KtFirOverrideInfoProvider(
override val analysisSession: KtAnalysisSession,
override val token: ValidityToken,
) : KtOverrideInfoProvider() {
private val firAnalysisSession = analysisSession as KtFirAnalysisSession
override fun isVisible(memberSymbol: KtCallableSymbol, classSymbol: KtClassOrObjectSymbol): Boolean {
require(memberSymbol is KtFirSymbol<*>)
require(classSymbol is KtFirSymbol<*>)
return memberSymbol.firRef.withFir { memberFir ->
if (memberFir !is FirCallableMemberDeclaration) return@withFir false
classSymbol.firRef.withFir inner@{ parentClassFir ->
if (parentClassFir !is FirClass) return@inner false
memberFir.isVisibleInClass(parentClassFir)
}
}
}
override fun getImplementationStatus(memberSymbol: KtCallableSymbol, parentClassSymbol: KtClassOrObjectSymbol): ImplementationStatus? {
require(memberSymbol is KtFirSymbol<*>)
require(parentClassSymbol is KtFirSymbol<*>)
return memberSymbol.firRef.withFir { memberFir ->
if (memberFir !is FirCallableMemberDeclaration) return@withFir null
parentClassSymbol.firRef.withFir inner@{ parentClassFir ->
if (parentClassFir !is FirClass) return@inner null
memberFir.getImplementationStatus(SessionHolderImpl(firAnalysisSession.rootModuleSession, ScopeSession()), parentClassFir)
}
}
}
override fun getOriginalContainingClassForOverride(symbol: KtCallableSymbol): KtClassOrObjectSymbol? {
require(symbol is KtFirSymbol<*>)
return symbol.firRef.withFir { firDeclaration ->
if (firDeclaration !is FirCallableMemberDeclaration) return@withFir null
with(analysisSession) {
getOriginalOverriddenSymbol(firDeclaration)?.containingClass()?.classId?.getCorrespondingToplevelClassOrObjectSymbol()
}
}
}
override fun getOriginalOverriddenSymbol(symbol: KtCallableSymbol): KtCallableSymbol? {
require(symbol is KtFirSymbol<*>)
return symbol.firRef.withFir { firDeclaration ->
if (firDeclaration !is FirCallableMemberDeclaration) return@withFir null
with(analysisSession) {
getOriginalOverriddenSymbol(firDeclaration)
?.buildSymbol((analysisSession as KtFirAnalysisSession).firSymbolBuilder) as KtCallableSymbol?
}
}
}
private fun getOriginalOverriddenSymbol(member: FirCallableMemberDeclaration): FirCallableMemberDeclaration? {
val originalForSubstitutionOverride = member.originalForSubstitutionOverride
if (originalForSubstitutionOverride != null) return getOriginalOverriddenSymbol(originalForSubstitutionOverride)
val originalForIntersectionOverrideAttr = member.originalForIntersectionOverrideAttr
if (originalForIntersectionOverrideAttr != null) return getOriginalOverriddenSymbol(originalForIntersectionOverrideAttr)
val delegatedWrapperData = member.delegatedWrapperData
if (delegatedWrapperData != null) return getOriginalOverriddenSymbol(delegatedWrapperData.wrapped)
return member
}
}
| 1 | null | 1 | 3 | 58c7aa9937334b7f3a70acca84a9ce59c35ab9d1 | 4,683 | kotlin | Apache License 2.0 |
weather-interface/src/main/java/org/rcgonzalezf/weather/common/network/ApiResponse.kt | rcgonzalezf | 43,210,997 | false | {"Java": 139401, "Kotlin": 114455} | package org.rcgonzalezf.weather.common.network
import org.rcgonzalezf.weather.common.models.converter.Data
interface ApiResponse<D : Data?> {
val data: List<D>?
}
| 19 | Java | 1 | 1 | 8302404110d044845412dff658d172991768350a | 169 | weather-app-demo | MIT License |
baselib/src/main/java/com/app/baselib/base/activity/BaseViewBindingViewModelActivity.kt | NewNum | 269,868,648 | false | {"Java": 73618, "Kotlin": 44696} | package com.app.baselib.base.activity
import android.view.LayoutInflater
import androidx.databinding.DataBindingUtil
import androidx.databinding.ViewDataBinding
import androidx.viewbinding.ViewBinding
/**
* 封装带有协程基类(DataBinding + ViewModel),使用代理类完成
*
*/
abstract class BaseViewBindingViewModelActivity<DB : ViewBinding> : BaseViewModelActivity() {
lateinit var db: DB
override fun setContentLayout() {
db = initViewBinding().invoke(layoutInflater)
setContentView(db.root)
initViewModelAction()
onViewCreate()
initData()
}
abstract fun initViewBinding(): ((
LayoutInflater,
) -> DB)
} | 1 | Java | 1 | 1 | 5135d18fd14792c9078494d3b0ef3a630fb524ac | 660 | JetpackDemo | Apache License 2.0 |
tmp/arrays/kotlinAndJava/366.kt | mandelshtamd | 346,008,310 | true | {"Kotlin": 7965847} | //File A.java
import kotlin.Metadata;
public enum A {
O,
K;
}
//File B.java
import kotlin.Metadata;
public enum B {
O,
K;
}
//File Main.kt
// !LANGUAGE: -ProhibitComparisonOfIncompatibleEnums
fun box(): String {
val a = A.O
val r1 = when (a) {
A.O -> "O"
A.K -> "K"
B.O -> "fail 1"
B.K -> "fail 2"
}
val b = B.K
val r2 = when (b) {
A.O -> "fail 3"
A.K -> "fail 4"
B.O -> "O"
B.K -> "K"
}
return r1 + r2
}
// 0 TABLESWITCH
// 0 LOOKUPSWITCH
| 1 | Kotlin | 1 | 1 | e772ef1f8f951873ebe7d8f6d73cf19aead480fa | 555 | kotlinWithFuzzer | Apache License 2.0 |
app/src/main/java/io/github/agussmkertjhaan/biniq/features/home/WasteLatest.kt | agussmkertjhaan | 793,624,832 | false | {"Kotlin": 143077, "Shell": 80} | package io.github.agussmkertjhaan.biniq.features.home
import androidx.compose.foundation.Image
import androidx.compose.foundation.background
import androidx.compose.foundation.clickable
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.size
import androidx.compose.material3.Card
import androidx.compose.material3.CardDefaults
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.livedata.observeAsState
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.RectangleShape
import androidx.compose.ui.graphics.painter.BitmapPainter
import androidx.compose.ui.layout.ContentScale
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.text.style.TextAlign
import androidx.compose.ui.unit.dp
import io.github.agussmkertjhaan.biniq.R
import io.github.agussmkertjhaan.biniq.domain.model.Waste
import io.github.agussmkertjhaan.biniq.ui.component.DialogWasteDetail
import io.github.agussmkertjhaan.biniq.ui.component.LoadingProgressComponent
import io.github.agussmkertjhaan.biniq.ui.component.TextLabelComponent
import io.github.agussmkertjhaan.biniq.utils.accuracyFormatter
import io.github.agussmkertjhaan.biniq.utils.urlBase64ToImage
@Composable
fun WasteLatest(
viewModel: HomeViewModel
) {
val wasteLatestState by viewModel.wasteLatestState.observeAsState()
var showDetailClassify by remember { mutableStateOf(false) }
var itemDetail by remember { mutableStateOf<Waste?>(null) }
TextLabelComponent(label = R.string.waste_latest)
wasteLatestState?.let { state ->
when (state) {
is HomeViewModel.WasteState.Content -> {
val data = state.wasteLatest
if (data.isEmpty()) {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.Center
) {
Text(
text = stringResource(R.string.waste_empty),
textAlign = TextAlign.Center
)
}
} else {
Column(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp),
verticalArrangement = Arrangement.Center,
) {
data.forEach { waste ->
Item(
waste = waste,
clicked = {
showDetailClassify = true
itemDetail = waste
}
)
}
}
}
}
is HomeViewModel.WasteState.Error -> {
Row(
modifier = Modifier
.fillMaxWidth()
.padding(horizontal = 16.dp),
verticalAlignment = Alignment.CenterVertically,
horizontalArrangement = Arrangement.Center
) {
Text(
text = stringResource(R.string.waste_empty),
textAlign = TextAlign.Center
)
}
}
HomeViewModel.WasteState.Loading -> {
LoadingProgressComponent()
}
}
}
// detail waste dialog
if (showDetailClassify) {
DialogWasteDetail(
waste = itemDetail!!,
onDismissRequest = { showDetailClassify = false },
)
}
}
@Composable
private fun Item(
waste: Waste,
clicked: () -> Unit
) {
Card(
modifier = Modifier
.fillMaxWidth()
.padding(vertical = 6.dp)
.background(Color.White)
.clickable(onClick = clicked),
shape = RectangleShape,
elevation = CardDefaults.cardElevation(
defaultElevation = 0.dp
),
) {
Row(
modifier = Modifier
.fillMaxWidth(),
verticalAlignment = Alignment.CenterVertically
) {
Column(
modifier = Modifier
.weight(1f)
.padding(horizontal = 8.dp, vertical = 4.dp),
) {
Text(
text = waste.dateString,
style = MaterialTheme.typography.titleSmall
)
Text(
text = "Waktu: ${waste.timeString}",
style = MaterialTheme.typography.bodyMedium
)
Text(
text = "Label: ${waste.label}",
style = MaterialTheme.typography.bodyMedium
)
Text(
text = "Akurasi: ${accuracyFormatter(waste.accuracy)}%",
style = MaterialTheme.typography.bodyMedium
)
}
if (waste.imageUrl.isNotEmpty()) {
Image(
painter = BitmapPainter(urlBase64ToImage(waste.imageUrl)),
contentDescription = "",
modifier = Modifier.size(100.dp),
contentScale = ContentScale.FillHeight
)
} else {
Image(
painter = painterResource(id = R.drawable.no_image),
contentDescription = "",
modifier = Modifier.size(100.dp),
contentScale = ContentScale.FillHeight
)
}
}
}
} | 0 | Kotlin | 0 | 1 | a01b834c52aabfd39da76d685f01ee14c8466a88 | 6,510 | TA-Android | MIT License |
dsl/src/main/kotlin/io/cloudshiftdev/awscdkdsl/services/quicksight/CfnTemplateDonutOptionsPropertyDsl.kt | cloudshiftinc | 667,063,030 | false | null | @file:Suppress(
"RedundantVisibilityModifier",
"RedundantUnitReturnType",
"RemoveRedundantQualifierName",
"unused",
"UnusedImport",
"ClassName",
"REDUNDANT_PROJECTION",
"DEPRECATION"
)
package io.cloudshiftdev.awscdkdsl.services.quicksight
import io.cloudshiftdev.awscdkdsl.common.CdkDslMarker
import software.amazon.awscdk.IResolvable
import software.amazon.awscdk.services.quicksight.CfnAnalysis
/**
* The options for configuring a donut chart or pie chart.
*
* Example:
* ```
* // The code below shows an example of how to instantiate this type.
* // The values are placeholders you should change.
* import software.amazon.awscdk.services.quicksight.*;
* DonutOptionsProperty donutOptionsProperty = DonutOptionsProperty.builder()
* .arcOptions(ArcOptionsProperty.builder()
* .arcThickness("arcThickness")
* .build())
* .donutCenterOptions(DonutCenterOptionsProperty.builder()
* .labelVisibility("labelVisibility")
* .build())
* .build();
* ```
*
* [Documentation](http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-quicksight-analysis-donutoptions.html)
*/
@CdkDslMarker
public class CfnAnalysisDonutOptionsPropertyDsl {
private val cdkBuilder: CfnAnalysis.DonutOptionsProperty.Builder =
CfnAnalysis.DonutOptionsProperty.builder()
/**
* @param arcOptions The option for define the arc of the chart shape. Valid values are as
* follows:.
* * `WHOLE` - A pie chart
* * `SMALL` - A small-sized donut chart
* * `MEDIUM` - A medium-sized donut chart
* * `LARGE` - A large-sized donut chart
*/
public fun arcOptions(arcOptions: IResolvable) {
cdkBuilder.arcOptions(arcOptions)
}
/**
* @param arcOptions The option for define the arc of the chart shape. Valid values are as
* follows:.
* * `WHOLE` - A pie chart
* * `SMALL` - A small-sized donut chart
* * `MEDIUM` - A medium-sized donut chart
* * `LARGE` - A large-sized donut chart
*/
public fun arcOptions(arcOptions: CfnAnalysis.ArcOptionsProperty) {
cdkBuilder.arcOptions(arcOptions)
}
/**
* @param donutCenterOptions The label options of the label that is displayed in the center of a
* donut chart. This option isn't available for pie charts.
*/
public fun donutCenterOptions(donutCenterOptions: IResolvable) {
cdkBuilder.donutCenterOptions(donutCenterOptions)
}
/**
* @param donutCenterOptions The label options of the label that is displayed in the center of a
* donut chart. This option isn't available for pie charts.
*/
public fun donutCenterOptions(donutCenterOptions: CfnAnalysis.DonutCenterOptionsProperty) {
cdkBuilder.donutCenterOptions(donutCenterOptions)
}
public fun build(): CfnAnalysis.DonutOptionsProperty = cdkBuilder.build()
}
| 4 | null | 0 | 3 | c59c6292cf08f0fc3280d61e7f8cff813a608a62 | 2,887 | awscdk-dsl-kotlin | Apache License 2.0 |
gradle/gradle-idea/src/org/jetbrains/kotlin/idea/scripting/gradle/GradleScriptNotificationProvider.kt | JetBrains | 278,369,660 | false | null | // Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.idea.scripting.gradle
import com.intellij.icons.AllIcons
import com.intellij.ide.actions.ImportModuleAction
import com.intellij.ide.util.PropertiesComponent
import com.intellij.openapi.externalSystem.service.project.wizard.AbstractExternalProjectImportProvider
import com.intellij.openapi.externalSystem.util.ExternalSystemApiUtil
import com.intellij.openapi.fileEditor.FileEditor
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.Key
import com.intellij.openapi.vfs.VirtualFile
import com.intellij.projectImport.ProjectImportProvider
import com.intellij.ui.EditorNotificationPanel
import com.intellij.ui.EditorNotifications
import org.jetbrains.kotlin.idea.KotlinFileType
import org.jetbrains.kotlin.idea.KotlinIdeaGradleBundle
import org.jetbrains.kotlin.idea.configuration.GRADLE_SYSTEM_ID
import org.jetbrains.kotlin.idea.core.util.KotlinIdeaCoreBundle
import org.jetbrains.kotlin.idea.scripting.gradle.legacy.GradleStandaloneScriptActionsManager
import org.jetbrains.kotlin.idea.scripting.gradle.roots.GradleBuildRootsLocator
import org.jetbrains.kotlin.idea.scripting.gradle.roots.GradleBuildRootsLocator.NotificationKind.*
import org.jetbrains.kotlin.idea.scripting.gradle.roots.GradleBuildRootsManager
import org.jetbrains.kotlin.idea.scripting.gradle.roots.Imported
import java.io.File
class GradleScriptNotificationProvider(private val project: Project) :
EditorNotifications.Provider<EditorNotificationPanel>() {
override fun getKey(): Key<EditorNotificationPanel> = KEY
override fun createNotificationPanel(file: VirtualFile, fileEditor: FileEditor): EditorNotificationPanel? {
if (!isGradleKotlinScript(file)) return null
if (file.fileType != KotlinFileType.INSTANCE) return null
val standaloneScriptActions = GradleStandaloneScriptActionsManager.getInstance(project)
val rootsManager = GradleBuildRootsManager.getInstance(project)
val scriptUnderRoot = rootsManager?.findScriptBuildRoot(file) ?: return null
// todo: this actions will be usefull only when gradle fix https://github.com/gradle/gradle/issues/12640
fun EditorNotificationPanel.showActionsToFixNotEvaluated() {
// suggest to reimport project if something changed after import
val build: Imported = scriptUnderRoot.nearest as? Imported ?: return
val importTs = build.data.importTs
if (!build.areRelatedFilesChangedBefore(file, importTs)) {
createActionLabel(getConfigurationsActionText()) {
rootsManager.updateStandaloneScripts {
runPartialGradleImport(project, build)
}
}
}
// suggest to choose new gradle project
createActionLabel(KotlinIdeaGradleBundle.message("notification.outsideAnything.linkAction")) {
linkProject(project, scriptUnderRoot)
}
}
return when (scriptUnderRoot.notificationKind) {
dontCare -> null
legacy -> {
val actions = standaloneScriptActions[file]
if (actions == null) null
else {
object : EditorNotificationPanel() {
val contextHelp = KotlinIdeaGradleBundle.message("notification.gradle.legacy.firstLoad.info")
init {
if (actions.isFirstLoad) {
text(KotlinIdeaGradleBundle.message("notification.gradle.legacy.firstLoad"))
toolTipText = contextHelp
} else {
text(KotlinIdeaCoreBundle.message("notification.text.script.configuration.has.been.changed"))
}
createActionLabel(KotlinIdeaCoreBundle.message("notification.action.text.load.script.configuration")) {
actions.reload()
}
createActionLabel(KotlinIdeaCoreBundle.message("notification.action.text.enable.auto.reload")) {
actions.enableAutoReload()
}
if (actions.isFirstLoad) {
contextHelp(contextHelp)
}
}
}
}
}
legacyOutside -> EditorNotificationPanel().apply {
text(KotlinIdeaGradleBundle.message("notification.gradle.legacy.outsideProject"))
createActionLabel(KotlinIdeaGradleBundle.message("notification.notEvaluatedInLastImport.addAsStandaloneAction")) {
rootsManager.updateStandaloneScripts {
addStandaloneScript(file.path)
}
}
contextHelp(KotlinIdeaGradleBundle.message("notification.gradle.legacy.outsideProject.addToStandaloneHelp"))
}
outsideAnything -> EditorNotificationPanel().apply {
text(KotlinIdeaGradleBundle.message("notification.outsideAnything.text"))
createActionLabel(KotlinIdeaGradleBundle.message("notification.outsideAnything.linkAction")) {
linkProject(project, scriptUnderRoot)
}
}
wasNotImportedAfterCreation -> EditorNotificationPanel().apply {
text(configurationsAreMissingRequestNeeded())
createActionLabel(getConfigurationsActionText()) {
val root = scriptUnderRoot.nearest
if (root != null) {
runPartialGradleImport(project, root)
}
}
val help = configurationsAreMissingRequestNeededHelp()
if (help != null) {
contextHelp(help)
}
}
notEvaluatedInLastImport -> EditorNotificationPanel().apply {
text(configurationsAreMissingAfterRequest())
// todo: this actions will be usefull only when gradle fix https://github.com/gradle/gradle/issues/12640
// showActionsToFixNotEvaluated()
createActionLabel(KotlinIdeaGradleBundle.message("notification.notEvaluatedInLastImport.addAsStandaloneAction")) {
rootsManager.updateStandaloneScripts {
addStandaloneScript(file.path)
}
}
contextHelp(KotlinIdeaGradleBundle.message("notification.notEvaluatedInLastImport.info"))
}
standalone, standaloneLegacy -> EditorNotificationPanel().apply {
val actions = standaloneScriptActions[file]
if (actions != null) {
text(
KotlinIdeaGradleBundle.message("notification.standalone.text") +
". " +
KotlinIdeaCoreBundle.message("notification.text.script.configuration.has.been.changed")
)
createActionLabel(KotlinIdeaCoreBundle.message("notification.action.text.load.script.configuration")) {
actions.reload()
}
createActionLabel(KotlinIdeaCoreBundle.message("notification.action.text.enable.auto.reload")) {
actions.enableAutoReload()
}
} else {
text(KotlinIdeaGradleBundle.message("notification.standalone.text"))
}
createActionLabel(KotlinIdeaGradleBundle.message("notification.standalone.disableScriptAction")) {
rootsManager.updateStandaloneScripts {
removeStandaloneScript(file.path)
}
}
if (scriptUnderRoot.notificationKind == standaloneLegacy) {
contextHelp(KotlinIdeaGradleBundle.message("notification.gradle.legacy.standalone.info"))
} else {
contextHelp(KotlinIdeaGradleBundle.message("notification.standalone.info"))
}
}
}
}
private fun linkProject(
project: Project,
scriptUnderRoot: GradleBuildRootsLocator.ScriptUnderRoot
) {
val settingsFile: File? = tryFindGradleSettings(scriptUnderRoot)
// from AttachExternalProjectAction
val manager = ExternalSystemApiUtil.getManager(GRADLE_SYSTEM_ID) ?: return
val provider = ProjectImportProvider.PROJECT_IMPORT_PROVIDER.extensions.find {
it is AbstractExternalProjectImportProvider && GRADLE_SYSTEM_ID == it.externalSystemId
} ?: return
val projectImportProviders = arrayOf(provider)
if (settingsFile != null) {
PropertiesComponent.getInstance().setValue(
"last.imported.location",
settingsFile.canonicalPath
)
}
val wizard = ImportModuleAction.selectFileAndCreateWizard(
project,
null,
manager.externalProjectDescriptor,
projectImportProviders
) ?: return
if (wizard.stepCount <= 0 || wizard.showAndGet()) {
ImportModuleAction.createFromWizard(project, wizard)
}
}
private fun tryFindGradleSettings(scriptUnderRoot: GradleBuildRootsLocator.ScriptUnderRoot): File? {
try {
var parent = File(scriptUnderRoot.filePath).canonicalFile.parentFile
while (parent.isDirectory) {
listOf("settings.gradle", "settings.gradle.kts").forEach {
val settings = parent.resolve(it)
if (settings.isFile) {
return settings
}
}
parent = parent.parentFile
}
} catch (t: Throwable) {
// ignore
}
return null
}
private fun EditorNotificationPanel.contextHelp(text: String) {
val helpIcon = createActionLabel("") {}
helpIcon.setIcon(AllIcons.General.ContextHelp)
helpIcon.setUseIconAsLink(true)
helpIcon.toolTipText = text
}
companion object {
private val KEY = Key.create<EditorNotificationPanel>("GradleScriptOutOfSourceNotification")
}
}
| 284 | null | 5162 | 82 | cc81d7505bc3e9ad503d706998ae8026c067e838 | 10,666 | intellij-kotlin | Apache License 2.0 |
mobile_app1/module831/src/main/java/module831packageKt0/Foo175.kt | uber-common | 294,831,672 | false | null | package module831packageKt0;
annotation class Foo175Fancy
@Foo175Fancy
class Foo175 {
fun foo0(){
module831packageKt0.Foo174().foo3()
}
fun foo1(){
foo0()
}
fun foo2(){
foo1()
}
fun foo3(){
foo2()
}
} | 6 | Java | 6 | 72 | 9cc83148c1ca37d0f2b2fcb08c71ac04b3749e5e | 237 | android-build-eval | Apache License 2.0 |
scripts/src/main/java/io/github/fate_grand_automata/scripts/models/ParsedCard.kt | Fate-Grand-Automata | 245,391,245 | false | null | package io.github.fate_grand_automata.scripts.models
import io.github.fate_grand_automata.scripts.enums.CardAffinityEnum
import io.github.fate_grand_automata.scripts.enums.CardTypeEnum
data class ParsedCard(
val card: CommandCard.Face,
val servant: TeamSlot,
val fieldSlot: FieldSlot?,
val type: CardTypeEnum,
val affinity: CardAffinityEnum = CardAffinityEnum.Normal,
val isStunned: Boolean = false
) {
override fun equals(other: Any?) =
other is ParsedCard && card == other.card
override fun hashCode() = card.hashCode()
} | 18 | Kotlin | 187 | 993 | eb630b8efcdb56782f796de2e17b36fdf9e19f3b | 566 | FGA | MIT License |
app/src/main/java/com/sethchhim/kuboo_client/service/OnClearFromRecentService.kt | befora | 137,512,422 | false | null | package com.sethchhim.kuboo_client.service
import android.app.Service
import android.content.Intent
import android.os.IBinder
import com.sethchhim.kuboo_client.BaseApplication
import javax.inject.Inject
class OnClearFromRecentService : Service() {
init {
BaseApplication.appComponent.inject(this)
}
@Inject lateinit var notificationService: NotificationService
override fun onBind(intent: Intent): IBinder? = null
override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int = Service.START_NOT_STICKY
override fun onTaskRemoved(rootIntent: Intent) {
super.onTaskRemoved(rootIntent)
notificationService.stopNotification()
stopSelf()
}
} | 1 | null | 39 | 81 | 33e456344172eab96b136e30130c4125096f253d | 718 | Kuboo | Apache License 2.0 |
lib/src/commonMain/kotlin/com/github/theapache64/pencilui/ui/PencilButton.kt | theapache64 | 456,120,022 | false | {"Kotlin": 33547} | package com.github.theapache64.pencilui.ui
import androidx.compose.animation.core.animateFloatAsState
import androidx.compose.foundation.BorderStroke
import androidx.compose.foundation.background
import androidx.compose.foundation.border
import androidx.compose.foundation.indication
import androidx.compose.foundation.interaction.MutableInteractionSource
import androidx.compose.foundation.interaction.PressInteraction
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.material.ripple.rememberRipple
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.scale
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.Shape
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import com.github.theapache64.pencilui.ui.common.LocalPencilUiDevConfig
import com.github.theapache64.pencilui.ui.common.PencilBorder
import com.github.theapache64.pencilui.ui.indication.firework.FireworkIndication
import com.github.theapache64.pencilui.util.addIf
import kotlinx.coroutines.flow.collect
@OptIn(ExperimentalMaterialApi::class)
@Composable
fun PencilButton(
onClick: () -> Unit,
modifier: Modifier = Modifier,
enabled: Boolean = true,
enableFireworkIndication: Boolean = false,
interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
elevation: ButtonElevation? = null,
shape: Shape = MaterialTheme.shapes.small,
colors: ButtonColors = ButtonDefaults.textButtonColors(),
contentPadding: PaddingValues = ButtonDefaults.TextButtonContentPadding,
borderWidth: Dp = PencilUiTheme.dimens.borderWidth,
textColor: Color = PencilUiTheme.color.contentColor,
disabledTextColor: Color = PencilUiTheme.color.disabledContentColor,
borderColor: Color = PencilUiTheme.color.borderColor,
disabledBorderColor: Color = PencilUiTheme.color.disabledBorderColor,
backgroundColor: Color = PencilUiTheme.color.buttonBgColor,
disabledBackgroundColor: Color = PencilUiTheme.color.disabledButtonBgColor,
border: BorderStroke = BorderStroke(width = borderWidth, color = if (enabled) borderColor else disabledBorderColor),
content: @Composable RowScope.() -> Unit
) {
val density = LocalDensity.current
val pencilBorder = remember { PencilBorder(density) }
var scale by remember { mutableStateOf(1f) }
val animatedScale by animateFloatAsState(
targetValue = scale,
// tween(durationMillis = 200)
)
LaunchedEffect(interactionSource) {
interactionSource.interactions.collect {
if (enabled) {
when (it) {
is PressInteraction.Press -> {
scale = 0.9f
}
is PressInteraction.Release, is PressInteraction.Cancel -> {
scale = 1f
}
}
}
}
}
Surface(
modifier = modifier
.scale(animatedScale)
.addIf(PencilUiTheme.dev.debug) {
background(LocalPencilUiDevConfig.current.debugColor)
}
.padding(all = (borderWidth.value * 2).dp)
.background(if (enabled) backgroundColor else disabledBackgroundColor, pencilBorder)
.addIf(enabled && enableFireworkIndication) {
indication(
interactionSource = interactionSource,
indication = remember { FireworkIndication() }
)
}
.border(
border = border,
shape = pencilBorder
),
shape = shape,
color = colors.backgroundColor(enabled).value,
contentColor = if (enabled) textColor else disabledTextColor,
elevation = elevation?.elevation(enabled, interactionSource)?.value ?: 0.dp,
indication = if (enabled) rememberRipple() else null,
interactionSource = interactionSource,
onClick = onClick
) {
val textColorAlpha = if (enabled) textColor.alpha else disabledTextColor.alpha
CompositionLocalProvider(LocalContentAlpha provides textColorAlpha) {
ProvideTextStyle(
value = MaterialTheme.typography.button
) {
Row(
Modifier
.defaultMinSize(
minWidth = ButtonDefaults.MinWidth,
minHeight = ButtonDefaults.MinHeight
)
.padding(contentPadding),
horizontalArrangement = Arrangement.Center,
verticalAlignment = Alignment.CenterVertically,
content = content
)
}
}
}
} | 0 | Kotlin | 0 | 47 | e8635e89dd6ac82c84ddd887a15198052c97007e | 4,934 | pencil-ui | Apache License 2.0 |
knowledge/src/main/java/com/google/android/fhir/knowledge/db/KnowledgeDatabase.kt | google | 247,977,633 | false | {"Kotlin": 3601315, "Shell": 6510, "Java": 454} | /*
* Copyright 2022-2023 Google LLC
*
* 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 com.google.android.fhir.knowledge.db.impl
import androidx.room.Database
import androidx.room.RoomDatabase
import androidx.room.TypeConverters
import com.google.android.fhir.knowledge.db.impl.dao.KnowledgeDao
import com.google.android.fhir.knowledge.db.impl.entities.ImplementationGuideEntity
import com.google.android.fhir.knowledge.db.impl.entities.ImplementationGuideResourceMetadataEntity
import com.google.android.fhir.knowledge.db.impl.entities.ResourceMetadataEntity
/**
* Stores knowledge artifacts metadata for implementation guides and their containing FHIR
* Resources.
*
* Same FhirResource (identified as the resource with the same `url`) can be part of the different
* IGs. To avoid duplications, [ImplementationGuideEntity] are connected with
* [ResourceMetadataEntity] through [ImplementationGuideResourceMetadataEntity] in a
* [many-to-many](https://developer.android.com/training/data-storage/room/relationships#many-to-many)
* relationship.
*/
@Database(
entities =
[
ImplementationGuideEntity::class,
ResourceMetadataEntity::class,
ImplementationGuideResourceMetadataEntity::class,
],
version = 1,
exportSchema = false,
)
@TypeConverters(DbTypeConverters::class)
internal abstract class KnowledgeDatabase : RoomDatabase() {
abstract fun knowledgeDao(): KnowledgeDao
}
| 325 | Kotlin | 288 | 485 | d417dde6c08d0a21b620754400b37e0fe131e679 | 1,942 | android-fhir | Apache License 2.0 |
app/src/main/java/com/movingmaker/commentdiary/di/network/OkHttpClientModule.kt | dudwls901 | 458,682,004 | false | {"Kotlin": 270966} | package com.movingmaker.commentdiary.di.network
import dagger.Module
import dagger.Provides
import dagger.hilt.InstallIn
import dagger.hilt.components.SingletonComponent
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import java.util.concurrent.TimeUnit
import javax.inject.Qualifier
import javax.inject.Singleton
@Module
@InstallIn(SingletonComponent::class)
object OkHttpClientModule {
@Qualifier
@Retention(AnnotationRetention.RUNTIME)
annotation class FirebaseInterceptorHttpClient
@Provides
@Singleton
@FirebaseInterceptorHttpClient
fun provideFirebaseInterceptorHttpClient(
httpLoggingInterceptor: HttpLoggingInterceptor,
): OkHttpClient {
return OkHttpClient.Builder()
.connectTimeout(5, TimeUnit.SECONDS)
.addInterceptor(httpLoggingInterceptor)
.build()
}
} | 9 | Kotlin | 0 | 1 | 32865202976a2586ec8aa3687467dcb40d93fdc9 | 884 | CommentDiary-Android | MIT License |
app/src/main/java/com/mnishiguchi/movingestimator2/ui/BaseFragment.kt | mnishiguchi | 97,773,891 | false | null | package com.mnishiguchi.movingestimator2.ui
import android.arch.lifecycle.LifecycleRegistry
import android.arch.lifecycle.LifecycleRegistryOwner
import android.content.Context
import android.os.Bundle
import android.support.v4.app.Fragment
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import org.jetbrains.anko.AnkoLogger
import org.jetbrains.anko.info
open class BaseFragment : Fragment(), LifecycleRegistryOwner, AnkoLogger {
// https://developer.android.com/reference/android/arch/lifecycle/LifecycleRegistryOwner.html
private val lifecycleRegistry = LifecycleRegistry(this)
override fun getLifecycle(): LifecycleRegistry = lifecycleRegistry
override fun onCreate(savedInstanceState: Bundle?) {
info("onCreate")
super.onCreate(savedInstanceState)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
info("onViewCreated")
super.onViewCreated(view, savedInstanceState)
}
override fun onActivityCreated(savedInstanceState: Bundle?) {
info("onActivityCreated")
super.onActivityCreated(savedInstanceState)
}
override fun onResume() {
info("onResume")
super.onResume()
}
override fun onPause() {
info("onPause")
super.onPause()
}
override fun onDestroy() {
info("onDestroy")
super.onDestroy()
}
override fun onAttach(context: Context?) {
info("onAttach")
super.onAttach(context)
}
override fun onDetach() {
info("onDetach")
super.onDetach()
}
}
| 0 | Kotlin | 0 | 0 | 5b4ec822894180abc42e83126835db85cca69982 | 1,623 | MovingEstimator2 | MIT License |
ReferenceAppKotlin/app/src/main/java/com/android/tv/reference/repository/FileVideoRepository.kt | takeoutfm | 398,114,096 | true | {"Markdown": 12, "Text": 1, "Ignore List": 9, "Java Properties": 9, "Gradle": 15, "Shell": 7, "Batchfile": 4, "Proguard": 5, "XML": 146, "HTML": 3, "JavaScript": 4, "JSON": 16, "Java": 208, "Kotlin": 101, "Makefile": 1, "Python": 3, "CSS": 1, "JSON with Comments": 2, "INI": 2, "Org": 2, "YAML": 6} | /*
* Copyright 2020 Google LLC
*
* 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
*
* https://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 com.android.tv.reference.repository
import android.app.Application
import com.android.tv.reference.shared.datamodel.*
import com.takeoutfm.tv.R
/**
* VideoRepository implementation to read video data from a file saved on /res/raw
*/
class FileVideoRepository(override val application: Application) : VideoRepository {
// Underscore name to allow lazy loading since "getAllVideos" matches the getter name otherwise
private val _allVideos: List<Video> by lazy {
val jsonString = readJsonFromFile()
VideoParser.loadVideosFromJson(jsonString)
}
private fun readJsonFromFile(): String {
val inputStream = application.resources.openRawResource(R.raw.api)
return inputStream.bufferedReader().use {
it.readText()
}
}
override suspend fun getAllVideos(refresh: Boolean): List<Video> {
return _allVideos
}
override suspend fun getHomeGroups(): List<VideoGroup> {
TODO("Not yet implemented")
}
override suspend fun getVideoDetail(id: String): Detail? {
TODO("Not yet implemented")
}
override suspend fun getProfile(id: String): Profile? {
TODO("Not yet implemented")
}
override suspend fun search(query: String): List<Video> {
TODO("Not yet implemented")
}
override fun getVideoById(id: String): Video? {
val jsonString = readJsonFromFile()
return VideoParser.findVideoFromJson(jsonString, id)
}
override fun getVideoByVideoUri(uri: String): Video? {
return _allVideos
.firstOrNull { it.videoUri == uri }
}
override fun getAllVideosFromSeries(seriesUri: String): List<Video> {
return _allVideos.filter { it.seriesUri == seriesUri }
}
override suspend fun updateProgress(progress: List<Progress>): Int {
TODO("Not yet implemented")
}
override fun getVideoProgress(video: Video): Progress? {
TODO("Not yet implemented")
}
override suspend fun getProgress(): List<Progress> {
TODO("Not yet implemented")
}
}
| 0 | Java | 0 | 0 | eb8a142c6ef28a97f68cb6b4577372c43ad59b60 | 2,681 | tv-samples | Apache License 2.0 |
standalone-sample/kmpviewmodel_compose_koject_sample/composeApp/src/commonMain/kotlin/com/hoc081098/solivagant/sample/todo/features/home/domain/RemoveItemById.kt | hoc081098 | 593,616,264 | false | {"Kotlin": 289858, "Swift": 1584, "Shell": 377, "HTML": 297} | package com.hoc081098.solivagant.sample.todo.features.home.domain
import com.hoc081098.solivagant.sample.todo.domain.TodoItem
import com.hoc081098.solivagant.sample.todo.domain.TodoItemRepository
import com.moriatsushi.koject.Provides
@Provides
internal class RemoveItemById(
private val todoItemRepository: TodoItemRepository,
) {
suspend operator fun invoke(id: TodoItem.Id): Result<Unit> =
todoItemRepository.removeById(id)
}
| 7 | Kotlin | 4 | 96 | 2a0974ea37c88fc3ef44b7c3b634c7cfbcefa33e | 439 | kmp-viewmodel | MIT License |
compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/1.fir.kt | JetBrains | 3,432,266 | false | null | // IGNORE_REVERSED_RESOLVE
// !DIAGNOSTICS: -UNUSED_EXPRESSION
// SKIP_TXT
// TODO: https://youtrack.jetbrains.com/issue/KT-49862
/*
* KOTLIN DIAGNOSTICS NOT LINKED SPEC TEST (POSITIVE)
*
* SECTIONS: dfa
* NUMBER: 1
* DESCRIPTION: Raw data flow analysis test
* HELPERS: classes, objects, functions, typealiases, properties, enumClasses
*/
// FILE: other_package.kt
package otherpackage
// TESTCASE NUMBER: 13
class Case13 {}
// TESTCASE NUMBER: 14
typealias Case14 = String?
// FILE: main.kt
import otherpackage.*
// TESTCASE NUMBER: 1
fun case_1(x: Any?) {
if (x != null) {
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>x<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>x<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>x<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>x<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>x<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>x<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>x<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>x<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>x<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>x<!>.funNullableAny()
}
}
/*
* TESTCASE NUMBER: 2
* UNEXPECTED BEHAVIOUR
* ISSUES: KT-28159
*/
fun case_2(x: Nothing?) {
if (<!SENSELESS_COMPARISON!>x !== null<!>) {
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing? & kotlin.Nothing")!>x<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Nothing? & kotlin.Nothing")!>x<!>.hashCode()
}
}
// TESTCASE NUMBER: 3
fun case_3() {
if (Object.prop_1 == null)
else {
Object.prop_1
Object.prop_1.equals(null)
Object.prop_1.propT
Object.prop_1.propAny
Object.prop_1.propNullableT
Object.prop_1.propNullableAny
Object.prop_1.funT()
Object.prop_1.funAny()
Object.prop_1.funNullableT()
Object.prop_1.funNullableAny()
}
}
// TESTCASE NUMBER: 4
fun case_4(x: Char?) {
if (x != null && true) {
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
}
}
// TESTCASE NUMBER: 5
fun case_5() {
val x: Unit? = null
if (x !== null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>x<!>
if (x !== null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>x<!>.equals(null)
if (x !== null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>x<!>.propT
if (x !== null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>x<!>.propAny
if (x !== null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>x<!>.propNullableT
if (x !== null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>x<!>.propNullableAny
if (x !== null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>x<!>.funT()
if (x !== null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>x<!>.funAny()
if (x !== null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>x<!>.funNullableT()
if (x !== null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>x<!>.funNullableAny()
}
// TESTCASE NUMBER: 6
fun case_6(x: EmptyClass?) {
val y = true
if (x != null && !y) {
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyClass? & EmptyClass")!>x<!>
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyClass? & EmptyClass")!>x<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyClass? & EmptyClass")!>x<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyClass? & EmptyClass")!>x<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyClass? & EmptyClass")!>x<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyClass? & EmptyClass")!>x<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyClass? & EmptyClass")!>x<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyClass? & EmptyClass")!>x<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyClass? & EmptyClass")!>x<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyClass? & EmptyClass")!>x<!>.funNullableAny()
}
}
// TESTCASE NUMBER: 7
fun case_7() {
if (nullableNumberProperty != null || <!SENSELESS_COMPARISON!><!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Nothing?")!>nullableNumberProperty<!> != null<!>) {
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>nullableNumberProperty<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>nullableNumberProperty<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>nullableNumberProperty<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>nullableNumberProperty<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>nullableNumberProperty<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>nullableNumberProperty<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>nullableNumberProperty<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>nullableNumberProperty<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>nullableNumberProperty<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>nullableNumberProperty<!>.funNullableAny()
}
}
// TESTCASE NUMBER: 8
fun case_8(x: TypealiasNullableString) {
if (x !== null && <!SENSELESS_COMPARISON!><!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!>
if (x !== null && <!SENSELESS_COMPARISON!><!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!>.equals(null)
if (x !== null && <!SENSELESS_COMPARISON!><!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!>.propT
if (x !== null && <!SENSELESS_COMPARISON!><!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!>.propAny
if (x !== null && <!SENSELESS_COMPARISON!><!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!>.propNullableT
if (x !== null && <!SENSELESS_COMPARISON!><!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!>.propNullableAny
if (x !== null && <!SENSELESS_COMPARISON!><!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!>.funT()
if (x !== null && <!SENSELESS_COMPARISON!><!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!>.funAny()
if (x !== null && <!SENSELESS_COMPARISON!><!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!>.funNullableT()
if (x !== null && <!SENSELESS_COMPARISON!><!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!> != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString & kotlin.String")!>x<!>.funNullableAny()
}
// TESTCASE NUMBER: 9
fun case_9(x: TypealiasNullableString?) {
if (x === null) {
} else if (false) {
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString? & kotlin.String")!>x<!>
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString? & kotlin.String")!>x<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString? & kotlin.String")!>x<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString? & kotlin.String")!>x<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString? & kotlin.String")!>x<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString? & kotlin.String")!>x<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString? & kotlin.String")!>x<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString? & kotlin.String")!>x<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString? & kotlin.String")!>x<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableString? & kotlin.String")!>x<!>.funNullableAny()
}
}
// TESTCASE NUMBER: 10
fun case_10() {
val a = Class()
if (a.prop_4 === null || true) {
if (a.prop_4 != null) {
a.prop_4
a.prop_4.equals(null)
a.prop_4.propT
a.prop_4.propAny
a.prop_4.propNullableT
a.prop_4.propNullableAny
a.prop_4.funT()
a.prop_4.funAny()
a.prop_4.funNullableT()
a.prop_4.funNullableAny()
}
}
}
// TESTCASE NUMBER: 11
fun case_11(x: TypealiasNullableStringIndirect?, y: TypealiasNullableStringIndirect) {
val t: TypealiasNullableStringIndirect = null
if (x == null) {
} else {
if (y != null) {
if (nullableStringProperty == null) {
if (t != null) {
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect? & kotlin.String")!>x<!>
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect? & kotlin.String")!>x<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect? & kotlin.String")!>x<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect? & kotlin.String")!>x<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect? & kotlin.String")!>x<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect? & kotlin.String")!>x<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect? & kotlin.String")!>x<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect? & kotlin.String")!>x<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect? & kotlin.String")!>x<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect? & kotlin.String")!>x<!>.funNullableAny()
}
}
}
}
}
// TESTCASE NUMBER: 12
fun case_12(x: TypealiasNullableStringIndirect, y: TypealiasNullableStringIndirect) =
if (x == null) "1"
else if (y === null) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect & kotlin.String")!>x<!>
else if (<!SENSELESS_COMPARISON!>y === null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect & kotlin.String")!>x<!>.equals(null)
else if (<!SENSELESS_COMPARISON!>y === null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect & kotlin.String")!>x<!>.propT
else if (<!SENSELESS_COMPARISON!>y === null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect & kotlin.String")!>x<!>.propAny
else if (<!SENSELESS_COMPARISON!>y === null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect & kotlin.String")!>x<!>.propNullableT
else if (<!SENSELESS_COMPARISON!>y === null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect & kotlin.String")!>x<!>.propNullableAny
else if (<!SENSELESS_COMPARISON!>y === null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect & kotlin.String")!>x<!>.funT()
else if (<!SENSELESS_COMPARISON!>y === null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect & kotlin.String")!>x<!>.funAny()
else if (<!SENSELESS_COMPARISON!>y === null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect & kotlin.String")!>x<!>.funNullableT()
else if (<!SENSELESS_COMPARISON!>y === null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableStringIndirect & kotlin.String")!>x<!>.funNullableAny()
else "-1"
// TESTCASE NUMBER: 13
fun case_13(x: otherpackage.Case13?) =
if (x == null) {
throw Exception()
} else {
<!DEBUG_INFO_EXPRESSION_TYPE("otherpackage.Case13? & otherpackage.Case13")!>x<!>
<!DEBUG_INFO_EXPRESSION_TYPE("otherpackage.Case13? & otherpackage.Case13")!>x<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("otherpackage.Case13? & otherpackage.Case13")!>x<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("otherpackage.Case13? & otherpackage.Case13")!>x<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("otherpackage.Case13? & otherpackage.Case13")!>x<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("otherpackage.Case13? & otherpackage.Case13")!>x<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("otherpackage.Case13? & otherpackage.Case13")!>x<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("otherpackage.Case13? & otherpackage.Case13")!>x<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("otherpackage.Case13? & otherpackage.Case13")!>x<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("otherpackage.Case13? & otherpackage.Case13")!>x<!>.funNullableAny()
}
// TESTCASE NUMBER: 14
class Case14 {
val x: otherpackage.Case14?
init {
x = otherpackage.Case14()
}
}
fun case_14() {
val a = Case14()
if (a.x != null) {
if (<!SENSELESS_COMPARISON!>a.x != null<!>) {
if (<!SENSELESS_COMPARISON!>a.x !== null<!>) {
if (<!SENSELESS_COMPARISON!>a.x != null<!>) {
if (<!SENSELESS_COMPARISON!>a.x != null<!>) {
if (<!SENSELESS_COMPARISON!>a.x != null<!>) {
if (<!SENSELESS_COMPARISON!>a.x !== null<!>) {
if (<!SENSELESS_COMPARISON!>a.x != null<!>) {
if (<!SENSELESS_COMPARISON!>a.x != null<!>) {
if (<!SENSELESS_COMPARISON!>a.x !== null<!>) {
if (<!SENSELESS_COMPARISON!>a.x != null<!>) {
if (<!SENSELESS_COMPARISON!>a.x != null<!>) {
if (<!SENSELESS_COMPARISON!>a.x != null<!>) {
if (<!SENSELESS_COMPARISON!>a.x !== null<!>) {
if (<!SENSELESS_COMPARISON!>a.x != null<!>) {
if (<!SENSELESS_COMPARISON!>a.x !== null<!>) {
a.x
a.x.equals(null)
a.x.propT
a.x.propAny
a.x.propNullableT
a.x.propNullableAny
a.x.funT()
a.x.funAny()
a.x.funNullableT()
a.x.funNullableAny()
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
// TESTCASE NUMBER: 15
fun case_15(x: EmptyObject) {
val t = if (<!SENSELESS_COMPARISON!>x === null<!>) "" else {
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyObject")!>x<!>
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyObject")!>x<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyObject")!>x<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyObject")!>x<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyObject")!>x<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyObject")!>x<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyObject")!>x<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyObject")!>x<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyObject")!>x<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("EmptyObject")!>x<!>.funNullableAny()
}
}
// TESTCASE NUMBER: 16
fun case_16() {
val x: TypealiasNullableNothing = null
if (<!SENSELESS_COMPARISON!>x != null<!>) {
<!DEBUG_INFO_EXPRESSION_TYPE("TypealiasNullableNothing & kotlin.Nothing")!>x<!>
}
}
// TESTCASE NUMBER: 17
val case_17 = if (nullableIntProperty == null) 0 else {
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>nullableIntProperty<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>nullableIntProperty<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>nullableIntProperty<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>nullableIntProperty<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>nullableIntProperty<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>nullableIntProperty<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>nullableIntProperty<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>nullableIntProperty<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>nullableIntProperty<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>nullableIntProperty<!>.funNullableAny()
}
//TESTCASE NUMBER: 18
fun case_18(a: DeepObject.A.B.C.D.E.F.G.J?) {
if (a != null) {
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.funNullableAny()
}
}
// TESTCASE NUMBER: 19
fun case_19(b: Boolean) {
val a = if (b) {
object {
val B19 = if (b) {
object {
val C19 = if (b) {
object {
val D19 = if (b) {
object {
val x: Number? = 10
}
} else null
}
} else null
}
} else null
}
} else null
if (a != null && a.B19 != null && a.B19.C19 != null && a.B19.C19.D19 != null && a.B19.C19.D19.x != null) {
a.B19.C19.D19.x
a.B19.C19.D19.x.equals(null)
a.B19.C19.D19.x.propT
a.B19.C19.D19.x.propAny
a.B19.C19.D19.x.propNullableT
a.B19.C19.D19.x.propNullableAny
a.B19.C19.D19.x.funT()
a.B19.C19.D19.x.funAny()
a.B19.C19.D19.x.funNullableT()
a.B19.C19.D19.x.funNullableAny()
}
}
// TESTCASE NUMBER: 20
fun case_20(b: Boolean) {
val a = object {
val B19 = object {
val C19 = object {
val D19 = if (b) {
object {}
} else null
}
}
}
if (a.B19.C19.D19 !== null) {
a.B19.C19.D19
a.B19.C19.D19.equals(null)
a.B19.C19.D19.propT
a.B19.C19.D19.propAny
a.B19.C19.D19.propNullableT
a.B19.C19.D19.propNullableAny
a.B19.C19.D19.funT()
a.B19.C19.D19.funAny()
a.B19.C19.D19.funNullableT()
a.B19.C19.D19.funNullableAny()
}
}
// TESTCASE NUMBER: 21
fun case_21() {
if (EnumClassWithNullableProperty.B.prop_1 !== null) {
EnumClassWithNullableProperty.B.prop_1
EnumClassWithNullableProperty.B.prop_1.equals(null)
EnumClassWithNullableProperty.B.prop_1.propT
EnumClassWithNullableProperty.B.prop_1.propAny
EnumClassWithNullableProperty.B.prop_1.propNullableT
EnumClassWithNullableProperty.B.prop_1.propNullableAny
EnumClassWithNullableProperty.B.prop_1.funT()
EnumClassWithNullableProperty.B.prop_1.funAny()
EnumClassWithNullableProperty.B.prop_1.funNullableT()
EnumClassWithNullableProperty.B.prop_1.funNullableAny()
}
}
// TESTCASE NUMBER: 22
fun case_22(a: (() -> Unit)?) {
if (a != null) {
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>a()<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>a()<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>a()<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>a()<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>a()<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>a()<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>a()<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>a()<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>a()<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit")!>a()<!>.funNullableAny()
}
}
// TESTCASE NUMBER: 23
fun case_23(a: ((Float) -> Int?)?, b: Float?) {
if (a != null && b !== null) {
val x = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>a(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>)<!>
if (x != null) {
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.funNullableAny()
}
}
}
// TESTCASE NUMBER: 24
fun case_24(a: ((() -> Unit) -> Unit)?, b: (() -> Unit)?) =
if (a !== null && b !== null) {
a(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>? & kotlin.Function0<kotlin.Unit>")!>b<!>)
a(b)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>? & kotlin.Function0<kotlin.Unit>")!>b<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>? & kotlin.Function0<kotlin.Unit>")!>b<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>? & kotlin.Function0<kotlin.Unit>")!>b<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>? & kotlin.Function0<kotlin.Unit>")!>b<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>? & kotlin.Function0<kotlin.Unit>")!>b<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>? & kotlin.Function0<kotlin.Unit>")!>b<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>? & kotlin.Function0<kotlin.Unit>")!>b<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>? & kotlin.Function0<kotlin.Unit>")!>b<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Function0<kotlin.Unit>? & kotlin.Function0<kotlin.Unit>")!>b<!>.funNullableAny()
} else null
// TESTCASE NUMBER: 25
fun case_25(b: Boolean) {
val x = {
if (b) object {
val a = 10
} else null
}
val y = if (b) x else null
if (y !== null) {
val z = <!DEBUG_INFO_EXPRESSION_TYPE("<anonymous>?")!>y()<!>
if (z != null) {
<!DEBUG_INFO_EXPRESSION_TYPE("<anonymous>? & <anonymous>")!>z<!>.a
<!DEBUG_INFO_EXPRESSION_TYPE("<anonymous>? & <anonymous>")!>z<!>.a.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("<anonymous>? & <anonymous>")!>z<!>.a.propT
<!DEBUG_INFO_EXPRESSION_TYPE("<anonymous>? & <anonymous>")!>z<!>.a.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("<anonymous>? & <anonymous>")!>z<!>.a.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("<anonymous>? & <anonymous>")!>z<!>.a.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("<anonymous>? & <anonymous>")!>z<!>.a.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("<anonymous>? & <anonymous>")!>z<!>.a.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("<anonymous>? & <anonymous>")!>z<!>.a.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("<anonymous>? & <anonymous>")!>z<!>.a.funNullableAny()
}
}
}
// TESTCASE NUMBER: 26
fun case_26(a: ((Float) -> Int?)?, b: Float?) {
if (a != null == true && b != null == true) {
val x = <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>a(<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>)<!>
if (x != null == true) {
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>x<!>.funNullableAny()
}
}
}
// TESTCASE NUMBER: 27
fun case_27() {
if (Object.prop_1 == null == true == true == true == true == true == true == true == true == true == true == true == true == true == true)
else {
Object.prop_1
Object.prop_1.equals(null)
Object.prop_1.propT
Object.prop_1.propAny
Object.prop_1.propNullableT
Object.prop_1.propNullableAny
Object.prop_1.funT()
Object.prop_1.funAny()
Object.prop_1.funNullableT()
Object.prop_1.funNullableAny()
}
}
//TESTCASE NUMBER: 28
fun case_28(a: DeepObject.A.B.C.D.E.F.G.J?) =
if (a != null == true == false == false == false == true == false == true == false == false == true == true) {
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.x
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("DeepObject.A.B.C.D.E.F.G.J? & DeepObject.A.B.C.D.E.F.G.J")!>a<!>.funNullableAny()
} else -1
// TESTCASE NUMBER: 29
open class Case29(a: Int?, val b: Float?, private val c: Unit?, protected val d: String?, internal val e: Char?, public val f: Any?) {
val x: Char? = '.'
private val y: Unit? = kotlin.Unit
protected val z: Int? = 12
public val u: String? = "..."
val s: Any?
val v: Int?
val w: Number?
val t: String? = if (u != null) this.u else null
init {
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.equals(null)
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.propT
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.propAny
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.propNullableT
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.propNullableAny
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.funT()
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.funAny()
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.funNullableT()
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.funNullableAny()
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.equals(null)
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propT
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propAny
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableT
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableAny
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funT()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funAny()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableT()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableAny()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>
if (this.b != null) this.b
if (this.b != null) this.b.equals(null)
if (this.b != null) this.b.propT
if (this.b != null) this.b.propAny
if (this.b != null) this.b.propNullableT
if (this.b != null) this.b.propNullableAny
if (this.b != null) this.b.funT()
if (this.b != null) this.b.funAny()
if (this.b != null) this.b.funNullableT()
if (this.b != null) this.b.funNullableAny()
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.equals(null)
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propT
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propAny
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableT
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableAny
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funT()
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funAny()
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableT()
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableAny()
if (b != null) this.b
if (b != null) this.b.equals(null)
if (b != null) this.b.propT
if (b != null) this.b.propAny
if (b != null) this.b.propNullableT
if (b != null) this.b.propNullableAny
if (b != null) this.b.funT()
if (b != null) this.b.funAny()
if (b != null) this.b.funNullableT()
if (b != null) this.b.funNullableAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.equals(null)
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propT
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propAny
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableT
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableAny
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funT()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableT()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.equals(null)
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.propT
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.propAny
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.propNullableT
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.propNullableAny
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.funT()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.funAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.funNullableT()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.funNullableAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.equals(null)
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propT
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propAny
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableT
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableAny
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funT()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funAny()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableT()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableAny()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>
if (this.c != null) this.c.equals(null)
if (this.c != null) this.c.propT
if (this.c != null) this.c.propAny
if (this.c != null) this.c.propNullableT
if (this.c != null) this.c.propNullableAny
if (this.c != null) this.c.funT()
if (this.c != null) this.c.funAny()
if (this.c != null) this.c.funNullableT()
if (this.c != null) this.c.funNullableAny()
if (this.c != null) this.c
if (c != null) this.c.equals(null)
if (c != null) this.c.propT
if (c != null) this.c.propAny
if (c != null) this.c.propNullableT
if (c != null) this.c.propNullableAny
if (c != null) this.c.funT()
if (c != null) this.c.funAny()
if (c != null) this.c.funNullableT()
if (c != null) this.c.funNullableAny()
if (c != null) this.c
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.equals(null)
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propT
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propAny
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableT
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableAny
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funT()
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funAny()
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableT()
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableAny()
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.equals(null)
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propT
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propAny
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableT
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableAny
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funT()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funAny()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableT()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableAny()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.equals(null)
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.propT
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.propAny
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.propNullableT
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.propNullableAny
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.funT()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.funAny()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.funNullableT()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.funNullableAny()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.equals(null)
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propT
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propAny
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableT
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableAny
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funT()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funAny()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableT()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableAny()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>
if (this.d != null) this.d.equals(null)
if (this.d != null) this.d.propT
if (this.d != null) this.d.propAny
if (this.d != null) this.d.propNullableT
if (this.d != null) this.d.propNullableAny
if (this.d != null) this.d.funT()
if (this.d != null) this.d.funAny()
if (this.d != null) this.d.funNullableT()
if (this.d != null) this.d.funNullableAny()
if (this.d != null) this.d
if (d != null) this.d.equals(null)
if (d != null) this.d.propT
if (d != null) this.d.propAny
if (d != null) this.d.propNullableT
if (d != null) this.d.propNullableAny
if (d != null) this.d.funT()
if (d != null) this.d.funAny()
if (d != null) this.d.funNullableT()
if (d != null) this.d.funNullableAny()
if (d != null) this.d
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.equals(null)
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propT
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propAny
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableT
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableAny
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funT()
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funAny()
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableT()
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableAny()
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.equals(null)
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propT
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propAny
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableT
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableAny
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funT()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funAny()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableT()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableAny()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.equals(null)
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.propT
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.propAny
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.propNullableT
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.propNullableAny
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.funT()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.funAny()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.funNullableT()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.funNullableAny()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.equals(null)
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propT
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propAny
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableT
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableAny
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funT()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funAny()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableT()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableAny()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>
if (this.e != null) this.e.equals(null)
if (this.e != null) this.e.propT
if (this.e != null) this.e.propAny
if (this.e != null) this.e.propNullableT
if (this.e != null) this.e.propNullableAny
if (this.e != null) this.e.funT()
if (this.e != null) this.e.funAny()
if (this.e != null) this.e.funNullableT()
if (this.e != null) this.e.funNullableAny()
if (this.e != null) this.e
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.equals(null)
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propT
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propAny
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableT
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableAny
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funT()
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funAny()
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableT()
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableAny()
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>
if (e != null) this.e.equals(null)
if (e != null) this.e.propT
if (e != null) this.e.propAny
if (e != null) this.e.propNullableT
if (e != null) this.e.propNullableAny
if (e != null) this.e.funT()
if (e != null) this.e.funAny()
if (e != null) this.e.funNullableT()
if (e != null) this.e.funNullableAny()
if (e != null) this.e
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.equals(null)
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propT
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propAny
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableT
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableAny
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funT()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funAny()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableT()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableAny()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.equals(null)
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.propT
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.propAny
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.propNullableT
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.propNullableAny
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.funT()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.funAny()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.funNullableT()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.funNullableAny()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.equals(null)
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propT
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propAny
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableT
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableAny
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funT()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funAny()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableT()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableAny()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>
if (this.f != null) this.f.equals(null)
if (this.f != null) this.f.propT
if (this.f != null) this.f.propAny
if (this.f != null) this.f.propNullableT
if (this.f != null) this.f.propNullableAny
if (this.f != null) this.f.funT()
if (this.f != null) this.f.funAny()
if (this.f != null) this.f.funNullableT()
if (this.f != null) this.f.funNullableAny()
if (this.f != null) this.f
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.equals(null)
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propT
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propAny
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableT
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableAny
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funT()
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funAny()
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableT()
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableAny()
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>
if (f != null) this.f.equals(null)
if (f != null) this.f.propT
if (f != null) this.f.propAny
if (f != null) this.f.propNullableT
if (f != null) this.f.propNullableAny
if (f != null) this.f.funT()
if (f != null) this.f.funAny()
if (f != null) this.f.funNullableT()
if (f != null) this.f.funNullableAny()
if (f != null) this.f
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.equals(null)
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propT
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propAny
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableT
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableAny
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funT()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funAny()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableT()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableAny()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.equals(null)
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.propT
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.propAny
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.propNullableT
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.propNullableAny
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.funT()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.funAny()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.funNullableT()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.funNullableAny()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (this.x != null) this.x.equals(null)
if (this.x != null) this.x.propT
if (this.x != null) this.x.propAny
if (this.x != null) this.x.propNullableT
if (this.x != null) this.x.propNullableAny
if (this.x != null) this.x.funT()
if (this.x != null) this.x.funAny()
if (this.x != null) this.x.funNullableT()
if (this.x != null) this.x.funNullableAny()
if (this.x != null) this.x
if (x != null) this.x.equals(null)
if (x != null) this.x.propT
if (x != null) this.x.propAny
if (x != null) this.x.propNullableT
if (x != null) this.x.propNullableAny
if (x != null) this.x.funT()
if (x != null) this.x.funAny()
if (x != null) this.x.funNullableT()
if (x != null) this.x.funNullableAny()
if (x != null) this.x
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.equals(null)
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propNullableT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propNullableAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funNullableT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funNullableAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (this.y != null) this.y.equals(null)
if (this.y != null) this.y.propT
if (this.y != null) this.y.propAny
if (this.y != null) this.y.propNullableT
if (this.y != null) this.y.propNullableAny
if (this.y != null) this.y.funT()
if (this.y != null) this.y.funAny()
if (this.y != null) this.y.funNullableT()
if (this.y != null) this.y.funNullableAny()
if (this.y != null) this.y
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (y != null) this.y.equals(null)
if (y != null) this.y.propT
if (y != null) this.y.propAny
if (y != null) this.y.propNullableT
if (y != null) this.y.propNullableAny
if (y != null) this.y.funT()
if (y != null) this.y.funAny()
if (y != null) this.y.funNullableT()
if (y != null) this.y.funNullableAny()
if (y != null) this.y
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.equals(null)
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propNullableT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propNullableAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funNullableT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funNullableAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.equals(null)
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propT
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propAny
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableT
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableAny
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funT()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funAny()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableT()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableAny()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>
if (this.z != null) this.z.equals(null)
if (this.z != null) this.z.propT
if (this.z != null) this.z.propAny
if (this.z != null) this.z.propNullableT
if (this.z != null) this.z.propNullableAny
if (this.z != null) this.z.funT()
if (this.z != null) this.z.funAny()
if (this.z != null) this.z.funNullableT()
if (this.z != null) this.z.funNullableAny()
if (this.z != null) this.z
if (z != null) this.z.equals(null)
if (z != null) this.z.propT
if (z != null) this.z.propAny
if (z != null) this.z.propNullableT
if (z != null) this.z.propNullableAny
if (z != null) this.z.funT()
if (z != null) this.z.funAny()
if (z != null) this.z.funNullableT()
if (z != null) this.z.funNullableAny()
if (z != null) this.z
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.equals(null)
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propT
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propAny
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableT
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableAny
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funT()
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funAny()
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableT()
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableAny()
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.equals(null)
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propT
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propAny
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableT
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableAny
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funT()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funAny()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableT()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableAny()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.equals(null)
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.propT
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.propAny
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.propNullableT
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.propNullableAny
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.funT()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.funAny()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.funNullableT()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.funNullableAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (this.u != null) this.u.equals(null)
if (this.u != null) this.u.propT
if (this.u != null) this.u.propAny
if (this.u != null) this.u.propNullableT
if (this.u != null) this.u.propNullableAny
if (this.u != null) this.u.funT()
if (this.u != null) this.u.funAny()
if (this.u != null) this.u.funNullableT()
if (this.u != null) this.u.funNullableAny()
if (this.u != null) this.u
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (u != null) this.u.equals(null)
if (u != null) this.u.propT
if (u != null) this.u.propAny
if (u != null) this.u.propNullableT
if (u != null) this.u.propNullableAny
if (u != null) this.u.funT()
if (u != null) this.u.funAny()
if (u != null) this.u.funNullableT()
if (u != null) this.u.funNullableAny()
if (u != null) this.u
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.equals(null)
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propNullableT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propNullableAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funNullableT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funNullableAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u
v = 0
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.equals(null)
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propNullableT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propNullableAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funNullableT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funNullableAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v
w = if (<!SENSELESS_COMPARISON!>null != null<!>) 10 else null
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int?")!>w<!>
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.equals(null)
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.equals(null)
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propT
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propAny
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableT
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableAny
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funT()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funAny()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableT()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableAny()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.equals(null)
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.equals(null)
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propNullableT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propNullableAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funNullableT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funNullableAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w
s = null
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>.hashCode()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>
if (<!SENSELESS_COMPARISON!>s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing")!>s<!>
if (<!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing")!>s<!>
if (<!SENSELESS_COMPARISON!>s != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing")!>s<!>
if (<!SENSELESS_COMPARISON!>s != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) this.s
}
fun test() {
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.equals(null)
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propT
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propAny
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableT
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableAny
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funT()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funAny()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableT()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableAny()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.equals(null)
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propT
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propAny
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableT
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableAny
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funT()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funAny()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableT()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableAny()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.equals(null)
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propT
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propAny
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableT
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableAny
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funT()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funAny()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableT()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableAny()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.equals(null)
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propT
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propAny
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableT
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableAny
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funT()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funAny()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableT()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableAny()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.equals(null)
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propT
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propAny
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableT
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableAny
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funT()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funAny()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableT()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableAny()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.equals(null)
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propT
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propAny
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableT
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableAny
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funT()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funAny()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableT()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableAny()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.equals(null)
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propNullableT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propNullableAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funNullableT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funNullableAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.equals(null)
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propT
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propAny
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propNullableT
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propNullableAny
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funT()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funAny()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funNullableT()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funNullableAny()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>
}
}
fun case_29(a: Case29) {
if (a.x !== null) a.x.equals(null)
if (a.x !== null) a.x.propT
if (a.x !== null) a.x.propAny
if (a.x !== null) a.x.propNullableT
if (a.x !== null) a.x.propNullableAny
if (a.x !== null) a.x.funT()
if (a.x !== null) a.x.funAny()
if (a.x !== null) a.x.funNullableT()
if (a.x !== null) a.x.funNullableAny()
if (a.x !== null) a.x
if (a.b !== null) a.b.equals(null)
if (a.b !== null) a.b.propT
if (a.b !== null) a.b.propAny
if (a.b !== null) a.b.propNullableT
if (a.b !== null) a.b.propNullableAny
if (a.b !== null) a.b.funT()
if (a.b !== null) a.b.funAny()
if (a.b !== null) a.b.funNullableT()
if (a.b !== null) a.b.funNullableAny()
if (a.b !== null) a.b
if (a.e !== null) a.e.equals(null)
if (a.e !== null) a.e.propT
if (a.e !== null) a.e.propAny
if (a.e !== null) a.e.propNullableT
if (a.e !== null) a.e.propNullableAny
if (a.e !== null) a.e.funT()
if (a.e !== null) a.e.funAny()
if (a.e !== null) a.e.funNullableT()
if (a.e !== null) a.e.funNullableAny()
if (a.e !== null) a.e
if (a.f !== null) a.f.equals(null)
if (a.f !== null) a.f.propT
if (a.f !== null) a.f.propAny
if (a.f !== null) a.f.propNullableT
if (a.f !== null) a.f.propNullableAny
if (a.f !== null) a.f.funT()
if (a.f !== null) a.f.funAny()
if (a.f !== null) a.f.funNullableT()
if (a.f !== null) a.f.funNullableAny()
if (a.f !== null) a.f
if (a.v != null) a.v.equals(null)
if (a.v != null) a.v.propT
if (a.v != null) a.v.propAny
if (a.v != null) a.v.propNullableT
if (a.v != null) a.v.propNullableAny
if (a.v != null) a.v.funT()
if (a.v != null) a.v.funAny()
if (a.v != null) a.v.funNullableT()
if (a.v != null) a.v.funNullableAny()
if (a.v != null) a.v
if (a.w != null) a.w.equals(null)
if (a.w != null) a.w.propT
if (a.w != null) a.w.propAny
if (a.w != null) a.w.propNullableT
if (a.w != null) a.w.propNullableAny
if (a.w != null) a.w.funT()
if (a.w != null) a.w.funAny()
if (a.w != null) a.w.funNullableT()
if (a.w != null) a.w.funNullableAny()
if (a.w != null) a.w
if (a.s != null) a.s.equals(null)
if (a.s != null) a.s.propT
if (a.s != null) a.s.propAny
if (a.s != null) a.s.propNullableT
if (a.s != null) a.s.propNullableAny
if (a.s != null) a.s.funT()
if (a.s != null) a.s.funAny()
if (a.s != null) a.s.funNullableT()
if (a.s != null) a.s.funNullableAny()
if (a.s != null) a.s
}
// TESTCASE NUMBER: 30
sealed class Case30(a: Int?, val b: Float?, private val c: Unit?, protected val d: String?, internal val e: Char?, public val f: Any?) {
val x: Char? = '.'
private val y: Unit? = kotlin.Unit
protected val z: Int? = 12
public val u: String? = "..."
val s: Any?
val v: Int?
val w: Number?
val t: String? = if (u != null) this.u else null
init {
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.equals(null)
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.propT
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.propAny
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.propNullableT
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.propNullableAny
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.funT()
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.funAny()
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.funNullableT()
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.funNullableAny()
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.equals(null)
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propT
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propAny
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableT
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableAny
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funT()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funAny()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableT()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableAny()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>
if (this.b != null) this.b.equals(null)
if (this.b != null) this.b.propT
if (this.b != null) this.b.propAny
if (this.b != null) this.b.propNullableT
if (this.b != null) this.b.propNullableAny
if (this.b != null) this.b.funT()
if (this.b != null) this.b.funAny()
if (this.b != null) this.b.funNullableT()
if (this.b != null) this.b.funNullableAny()
if (this.b != null) this.b
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.equals(null)
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propT
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propAny
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableT
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableAny
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funT()
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funAny()
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableT()
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableAny()
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>
if (b != null) this.b.equals(null)
if (b != null) this.b.propT
if (b != null) this.b.propAny
if (b != null) this.b.propNullableT
if (b != null) this.b.propNullableAny
if (b != null) this.b.funT()
if (b != null) this.b.funAny()
if (b != null) this.b.funNullableT()
if (b != null) this.b.funNullableAny()
if (b != null) this.b
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.equals(null)
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propT
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propAny
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableT
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableAny
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funT()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableT()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.equals(null)
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.propT
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.propAny
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.propNullableT
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.propNullableAny
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.funT()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.funAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.funNullableT()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.funNullableAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.equals(null)
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propT
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propAny
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableT
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableAny
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funT()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funAny()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableT()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableAny()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>
if (this.c != null) this.c.equals(null)
if (this.c != null) this.c.propT
if (this.c != null) this.c.propAny
if (this.c != null) this.c.propNullableT
if (this.c != null) this.c.propNullableAny
if (this.c != null) this.c.funT()
if (this.c != null) this.c.funAny()
if (this.c != null) this.c.funNullableT()
if (this.c != null) this.c.funNullableAny()
if (this.c != null) this.c
if (c != null) this.c.equals(null)
if (c != null) this.c.propT
if (c != null) this.c.propAny
if (c != null) this.c.propNullableT
if (c != null) this.c.propNullableAny
if (c != null) this.c.funT()
if (c != null) this.c.funAny()
if (c != null) this.c.funNullableT()
if (c != null) this.c.funNullableAny()
if (c != null) this.c
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.equals(null)
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propT
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propAny
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableT
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableAny
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funT()
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funAny()
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableT()
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableAny()
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.equals(null)
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propT
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propAny
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableT
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableAny
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funT()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funAny()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableT()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableAny()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.equals(null)
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.propT
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.propAny
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.propNullableT
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.propNullableAny
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.funT()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.funAny()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.funNullableT()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.funNullableAny()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.equals(null)
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propT
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propAny
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableT
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableAny
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funT()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funAny()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableT()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableAny()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>
if (this.d != null) this.d.equals(null)
if (this.d != null) this.d.propT
if (this.d != null) this.d.propAny
if (this.d != null) this.d.propNullableT
if (this.d != null) this.d.propNullableAny
if (this.d != null) this.d.funT()
if (this.d != null) this.d.funAny()
if (this.d != null) this.d.funNullableT()
if (this.d != null) this.d.funNullableAny()
if (this.d != null) this.d
if (d != null) this.d.equals(null)
if (d != null) this.d.propT
if (d != null) this.d.propAny
if (d != null) this.d.propNullableT
if (d != null) this.d.propNullableAny
if (d != null) this.d.funT()
if (d != null) this.d.funAny()
if (d != null) this.d.funNullableT()
if (d != null) this.d.funNullableAny()
if (d != null) this.d
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.equals(null)
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propT
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propAny
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableT
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableAny
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funT()
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funAny()
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableT()
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableAny()
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.equals(null)
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propT
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propAny
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableT
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableAny
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funT()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funAny()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableT()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableAny()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.equals(null)
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.propT
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.propAny
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.propNullableT
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.propNullableAny
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.funT()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.funAny()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.funNullableT()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.funNullableAny()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.equals(null)
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propT
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propAny
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableT
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableAny
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funT()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funAny()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableT()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableAny()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>
if (this.e != null) this.e.equals(null)
if (this.e != null) this.e.propT
if (this.e != null) this.e.propAny
if (this.e != null) this.e.propNullableT
if (this.e != null) this.e.propNullableAny
if (this.e != null) this.e.funT()
if (this.e != null) this.e.funAny()
if (this.e != null) this.e.funNullableT()
if (this.e != null) this.e.funNullableAny()
if (this.e != null) this.e
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.equals(null)
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propT
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propAny
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableT
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableAny
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funT()
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funAny()
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableT()
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableAny()
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>
if (e != null) this.e.equals(null)
if (e != null) this.e.propT
if (e != null) this.e.propAny
if (e != null) this.e.propNullableT
if (e != null) this.e.propNullableAny
if (e != null) this.e.funT()
if (e != null) this.e.funAny()
if (e != null) this.e.funNullableT()
if (e != null) this.e.funNullableAny()
if (e != null) this.e
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.equals(null)
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propT
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propAny
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableT
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableAny
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funT()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funAny()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableT()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableAny()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.equals(null)
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.propT
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.propAny
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.propNullableT
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.propNullableAny
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.funT()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.funAny()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.funNullableT()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.funNullableAny()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.equals(null)
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propT
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propAny
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableT
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableAny
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funT()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funAny()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableT()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableAny()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>
if (this.f != null) this.f.equals(null)
if (this.f != null) this.f.propT
if (this.f != null) this.f.propAny
if (this.f != null) this.f.propNullableT
if (this.f != null) this.f.propNullableAny
if (this.f != null) this.f.funT()
if (this.f != null) this.f.funAny()
if (this.f != null) this.f.funNullableT()
if (this.f != null) this.f.funNullableAny()
if (this.f != null) this.f
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.equals(null)
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propT
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propAny
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableT
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableAny
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funT()
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funAny()
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableT()
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableAny()
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>
if (f != null) this.f.equals(null)
if (f != null) this.f.propT
if (f != null) this.f.propAny
if (f != null) this.f.propNullableT
if (f != null) this.f.propNullableAny
if (f != null) this.f.funT()
if (f != null) this.f.funAny()
if (f != null) this.f.funNullableT()
if (f != null) this.f.funNullableAny()
if (f != null) this.f
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.equals(null)
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propT
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propAny
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableT
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableAny
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funT()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funAny()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableT()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableAny()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.equals(null)
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.propT
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.propAny
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.propNullableT
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.propNullableAny
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.funT()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.funAny()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.funNullableT()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.funNullableAny()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (this.x != null) this.x.equals(null)
if (this.x != null) this.x.propT
if (this.x != null) this.x.propAny
if (this.x != null) this.x.propNullableT
if (this.x != null) this.x.propNullableAny
if (this.x != null) this.x.funT()
if (this.x != null) this.x.funAny()
if (this.x != null) this.x.funNullableT()
if (this.x != null) this.x.funNullableAny()
if (this.x != null) this.x
if (x != null) this.x.equals(null)
if (x != null) this.x.propT
if (x != null) this.x.propAny
if (x != null) this.x.propNullableT
if (x != null) this.x.propNullableAny
if (x != null) this.x.funT()
if (x != null) this.x.funAny()
if (x != null) this.x.funNullableT()
if (x != null) this.x.funNullableAny()
if (x != null) this.x
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.equals(null)
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propNullableT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propNullableAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funNullableT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funNullableAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (this.y != null) this.y.equals(null)
if (this.y != null) this.y.propT
if (this.y != null) this.y.propAny
if (this.y != null) this.y.propNullableT
if (this.y != null) this.y.propNullableAny
if (this.y != null) this.y.funT()
if (this.y != null) this.y.funAny()
if (this.y != null) this.y.funNullableT()
if (this.y != null) this.y.funNullableAny()
if (this.y != null) this.y
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (y != null) this.y.equals(null)
if (y != null) this.y.propT
if (y != null) this.y.propAny
if (y != null) this.y.propNullableT
if (y != null) this.y.propNullableAny
if (y != null) this.y.funT()
if (y != null) this.y.funAny()
if (y != null) this.y.funNullableT()
if (y != null) this.y.funNullableAny()
if (y != null) this.y
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.equals(null)
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propNullableT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propNullableAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funNullableT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funNullableAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.equals(null)
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propT
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propAny
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableT
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableAny
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funT()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funAny()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableT()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableAny()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>
if (this.z != null) this.z.equals(null)
if (this.z != null) this.z.propT
if (this.z != null) this.z.propAny
if (this.z != null) this.z.propNullableT
if (this.z != null) this.z.propNullableAny
if (this.z != null) this.z.funT()
if (this.z != null) this.z.funAny()
if (this.z != null) this.z.funNullableT()
if (this.z != null) this.z.funNullableAny()
if (this.z != null) this.z
if (z != null) this.z.equals(null)
if (z != null) this.z.propT
if (z != null) this.z.propAny
if (z != null) this.z.propNullableT
if (z != null) this.z.propNullableAny
if (z != null) this.z.funT()
if (z != null) this.z.funAny()
if (z != null) this.z.funNullableT()
if (z != null) this.z.funNullableAny()
if (z != null) this.z
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.equals(null)
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propT
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propAny
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableT
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableAny
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funT()
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funAny()
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableT()
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableAny()
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.equals(null)
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propT
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propAny
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableT
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableAny
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funT()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funAny()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableT()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableAny()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.equals(null)
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.propT
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.propAny
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.propNullableT
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.propNullableAny
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.funT()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.funAny()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.funNullableT()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.funNullableAny()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (this.u != null) this.u.equals(null)
if (this.u != null) this.u.propT
if (this.u != null) this.u.propAny
if (this.u != null) this.u.propNullableT
if (this.u != null) this.u.propNullableAny
if (this.u != null) this.u.funT()
if (this.u != null) this.u.funAny()
if (this.u != null) this.u.funNullableT()
if (this.u != null) this.u.funNullableAny()
if (this.u != null) this.u
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (u != null) this.u.equals(null)
if (u != null) this.u.propT
if (u != null) this.u.propAny
if (u != null) this.u.propNullableT
if (u != null) this.u.propNullableAny
if (u != null) this.u.funT()
if (u != null) this.u.funAny()
if (u != null) this.u.funNullableT()
if (u != null) this.u.funNullableAny()
if (u != null) this.u
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.equals(null)
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propNullableT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propNullableAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funNullableT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funNullableAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u
v = 0
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.equals(null)
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propNullableT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propNullableAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funNullableT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funNullableAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v
w = if (<!SENSELESS_COMPARISON!>null != null<!>) 10 else null
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int?")!>w<!>
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.equals(null)
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.equals(null)
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propT
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propAny
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableT
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableAny
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funT()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funAny()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableT()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableAny()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.equals(null)
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.equals(null)
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propNullableT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propNullableAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funNullableT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funNullableAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w
s = null
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>.hashCode()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>
if (<!SENSELESS_COMPARISON!>s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing")!>s<!>
if (<!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing")!>s<!>
if (<!SENSELESS_COMPARISON!>s != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing")!>s<!>
if (<!SENSELESS_COMPARISON!>s != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) this.s
}
fun test() {
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.equals(null)
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propT
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propAny
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableT
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableAny
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funT()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funAny()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableT()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableAny()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.equals(null)
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propT
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propAny
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableT
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableAny
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funT()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funAny()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableT()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableAny()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.equals(null)
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propT
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propAny
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableT
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableAny
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funT()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funAny()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableT()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableAny()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.equals(null)
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propT
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propAny
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableT
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableAny
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funT()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funAny()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableT()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableAny()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.equals(null)
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propT
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propAny
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableT
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableAny
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funT()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funAny()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableT()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableAny()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.equals(null)
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propT
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propAny
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableT
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableAny
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funT()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funAny()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableT()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableAny()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.equals(null)
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propNullableT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propNullableAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funNullableT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funNullableAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.equals(null)
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propT
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propAny
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propNullableT
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propNullableAny
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funT()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funAny()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funNullableT()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funNullableAny()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>
}
}
fun case_30(a: Case30) {
if (a.x !== null) a.x.equals(null)
if (a.x !== null) a.x.propT
if (a.x !== null) a.x.propAny
if (a.x !== null) a.x.propNullableT
if (a.x !== null) a.x.propNullableAny
if (a.x !== null) a.x.funT()
if (a.x !== null) a.x.funAny()
if (a.x !== null) a.x.funNullableT()
if (a.x !== null) a.x.funNullableAny()
if (a.x !== null) a.x
if (a.b !== null) a.b.equals(null)
if (a.b !== null) a.b.propT
if (a.b !== null) a.b.propAny
if (a.b !== null) a.b.propNullableT
if (a.b !== null) a.b.propNullableAny
if (a.b !== null) a.b.funT()
if (a.b !== null) a.b.funAny()
if (a.b !== null) a.b.funNullableT()
if (a.b !== null) a.b.funNullableAny()
if (a.b !== null) a.b
if (a.e !== null) a.e.equals(null)
if (a.e !== null) a.e.propT
if (a.e !== null) a.e.propAny
if (a.e !== null) a.e.propNullableT
if (a.e !== null) a.e.propNullableAny
if (a.e !== null) a.e.funT()
if (a.e !== null) a.e.funAny()
if (a.e !== null) a.e.funNullableT()
if (a.e !== null) a.e.funNullableAny()
if (a.e !== null) a.e
if (a.f !== null) a.f.equals(null)
if (a.f !== null) a.f.propT
if (a.f !== null) a.f.propAny
if (a.f !== null) a.f.propNullableT
if (a.f !== null) a.f.propNullableAny
if (a.f !== null) a.f.funT()
if (a.f !== null) a.f.funAny()
if (a.f !== null) a.f.funNullableT()
if (a.f !== null) a.f.funNullableAny()
if (a.f !== null) a.f
if (a.v != null) a.v.equals(null)
if (a.v != null) a.v.propT
if (a.v != null) a.v.propAny
if (a.v != null) a.v.propNullableT
if (a.v != null) a.v.propNullableAny
if (a.v != null) a.v.funT()
if (a.v != null) a.v.funAny()
if (a.v != null) a.v.funNullableT()
if (a.v != null) a.v.funNullableAny()
if (a.v != null) a.v
if (a.w != null) a.w.equals(null)
if (a.w != null) a.w.propT
if (a.w != null) a.w.propAny
if (a.w != null) a.w.propNullableT
if (a.w != null) a.w.propNullableAny
if (a.w != null) a.w.funT()
if (a.w != null) a.w.funAny()
if (a.w != null) a.w.funNullableT()
if (a.w != null) a.w.funNullableAny()
if (a.w != null) a.w
if (a.s != null) a.s.equals(null)
if (a.s != null) a.s.propT
if (a.s != null) a.s.propAny
if (a.s != null) a.s.propNullableT
if (a.s != null) a.s.propNullableAny
if (a.s != null) a.s.funT()
if (a.s != null) a.s.funAny()
if (a.s != null) a.s.funNullableT()
if (a.s != null) a.s.funNullableAny()
if (a.s != null) a.s
}
// TESTCASE NUMBER: 31
enum class Case31(a: Int?, val b: Float?, private val c: Unit?, protected val d: String?, internal val e: Char?, public val f: Any?) {
A(1, 2f, kotlin.Unit, "", ',', null), B(1, 2f, kotlin.Unit, "", ',', null), C(1, 2f, kotlin.Unit, "", ',', null);
val x: Char? = '.'
private val y: Unit? = kotlin.Unit
protected val z: Int? = 12
public val u: String? = "..."
val s: Any?
val v: Int?
val w: Number?
val t: String? = if (u != null) this.u else null
init {
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.equals(null)
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.propT
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.propAny
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.propNullableT
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.propNullableAny
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.funT()
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.funAny()
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.funNullableT()
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>.funNullableAny()
if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!>
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.equals(null)
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propT
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propAny
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableT
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableAny
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funT()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funAny()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableT()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableAny()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>
if (this.b != null) this.b.equals(null)
if (this.b != null) this.b.propT
if (this.b != null) this.b.propAny
if (this.b != null) this.b.propNullableT
if (this.b != null) this.b.propNullableAny
if (this.b != null) this.b.funT()
if (this.b != null) this.b.funAny()
if (this.b != null) this.b.funNullableT()
if (this.b != null) this.b.funNullableAny()
if (this.b != null) this.b
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.equals(null)
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propT
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propAny
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableT
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableAny
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funT()
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funAny()
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableT()
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableAny()
if (this.b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>
if (b != null) this.b.equals(null)
if (b != null) this.b.propT
if (b != null) this.b.propAny
if (b != null) this.b.propNullableT
if (b != null) this.b.propNullableAny
if (b != null) this.b.funT()
if (b != null) this.b.funAny()
if (b != null) this.b.funNullableT()
if (b != null) this.b.funNullableAny()
if (b != null) this.b
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.equals(null)
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propT
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propAny
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableT
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableAny
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funT()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableT()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.equals(null)
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.propT
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.propAny
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.propNullableT
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.propNullableAny
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.funT()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.funAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.funNullableT()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b.funNullableAny()
if (b != null || <!SENSELESS_COMPARISON!>this.b != null<!>) this.b
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.equals(null)
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propT
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propAny
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableT
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableAny
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funT()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funAny()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableT()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableAny()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>
if (this.c != null) this.c.equals(null)
if (this.c != null) this.c.propT
if (this.c != null) this.c.propAny
if (this.c != null) this.c.propNullableT
if (this.c != null) this.c.propNullableAny
if (this.c != null) this.c.funT()
if (this.c != null) this.c.funAny()
if (this.c != null) this.c.funNullableT()
if (this.c != null) this.c.funNullableAny()
if (this.c != null) this.c
if (c != null) this.c.equals(null)
if (c != null) this.c.propT
if (c != null) this.c.propAny
if (c != null) this.c.propNullableT
if (c != null) this.c.propNullableAny
if (c != null) this.c.funT()
if (c != null) this.c.funAny()
if (c != null) this.c.funNullableT()
if (c != null) this.c.funNullableAny()
if (c != null) this.c
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.equals(null)
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propT
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propAny
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableT
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableAny
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funT()
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funAny()
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableT()
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableAny()
if (this.c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.equals(null)
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propT
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propAny
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableT
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableAny
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funT()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funAny()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableT()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableAny()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.equals(null)
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.propT
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.propAny
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.propNullableT
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.propNullableAny
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.funT()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.funAny()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.funNullableT()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c.funNullableAny()
if (c != null || <!SENSELESS_COMPARISON!>this.c != null<!>) this.c
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.equals(null)
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propT
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propAny
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableT
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableAny
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funT()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funAny()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableT()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableAny()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>
if (this.d != null) this.d.equals(null)
if (this.d != null) this.d.propT
if (this.d != null) this.d.propAny
if (this.d != null) this.d.propNullableT
if (this.d != null) this.d.propNullableAny
if (this.d != null) this.d.funT()
if (this.d != null) this.d.funAny()
if (this.d != null) this.d.funNullableT()
if (this.d != null) this.d.funNullableAny()
if (this.d != null) this.d
if (d != null) this.d.equals(null)
if (d != null) this.d.propT
if (d != null) this.d.propAny
if (d != null) this.d.propNullableT
if (d != null) this.d.propNullableAny
if (d != null) this.d.funT()
if (d != null) this.d.funAny()
if (d != null) this.d.funNullableT()
if (d != null) this.d.funNullableAny()
if (d != null) this.d
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.equals(null)
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propT
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propAny
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableT
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableAny
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funT()
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funAny()
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableT()
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableAny()
if (this.d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.equals(null)
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propT
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propAny
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableT
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableAny
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funT()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funAny()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableT()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableAny()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.equals(null)
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.propT
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.propAny
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.propNullableT
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.propNullableAny
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.funT()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.funAny()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.funNullableT()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d.funNullableAny()
if (d != null || <!SENSELESS_COMPARISON!>this.d != null<!>) this.d
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.equals(null)
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propT
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propAny
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableT
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableAny
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funT()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funAny()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableT()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableAny()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>
if (this.e != null) this.e.equals(null)
if (this.e != null) this.e.propT
if (this.e != null) this.e.propAny
if (this.e != null) this.e.propNullableT
if (this.e != null) this.e.propNullableAny
if (this.e != null) this.e.funT()
if (this.e != null) this.e.funAny()
if (this.e != null) this.e.funNullableT()
if (this.e != null) this.e.funNullableAny()
if (this.e != null) this.e
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.equals(null)
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propT
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propAny
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableT
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableAny
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funT()
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funAny()
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableT()
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableAny()
if (this.e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>
if (e != null) this.e.equals(null)
if (e != null) this.e.propT
if (e != null) this.e.propAny
if (e != null) this.e.propNullableT
if (e != null) this.e.propNullableAny
if (e != null) this.e.funT()
if (e != null) this.e.funAny()
if (e != null) this.e.funNullableT()
if (e != null) this.e.funNullableAny()
if (e != null) this.e
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.equals(null)
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propT
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propAny
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableT
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableAny
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funT()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funAny()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableT()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableAny()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.equals(null)
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.propT
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.propAny
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.propNullableT
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.propNullableAny
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.funT()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.funAny()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.funNullableT()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e.funNullableAny()
if (e != null || <!SENSELESS_COMPARISON!>this.e != null<!>) this.e
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.equals(null)
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propT
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propAny
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableT
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableAny
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funT()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funAny()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableT()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableAny()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>
if (this.f != null) this.f.equals(null)
if (this.f != null) this.f.propT
if (this.f != null) this.f.propAny
if (this.f != null) this.f.propNullableT
if (this.f != null) this.f.propNullableAny
if (this.f != null) this.f.funT()
if (this.f != null) this.f.funAny()
if (this.f != null) this.f.funNullableT()
if (this.f != null) this.f.funNullableAny()
if (this.f != null) this.f
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.equals(null)
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propT
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propAny
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableT
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableAny
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funT()
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funAny()
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableT()
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableAny()
if (this.f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>
if (f != null) this.f.equals(null)
if (f != null) this.f.propT
if (f != null) this.f.propAny
if (f != null) this.f.propNullableT
if (f != null) this.f.propNullableAny
if (f != null) this.f.funT()
if (f != null) this.f.funAny()
if (f != null) this.f.funNullableT()
if (f != null) this.f.funNullableAny()
if (f != null) this.f
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.equals(null)
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propT
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propAny
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableT
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableAny
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funT()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funAny()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableT()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableAny()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.equals(null)
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.propT
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.propAny
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.propNullableT
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.propNullableAny
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.funT()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.funAny()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.funNullableT()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f.funNullableAny()
if (f != null || <!SENSELESS_COMPARISON!>this.f != null<!>) this.f
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (this.x != null) this.x.equals(null)
if (this.x != null) this.x.propT
if (this.x != null) this.x.propAny
if (this.x != null) this.x.propNullableT
if (this.x != null) this.x.propNullableAny
if (this.x != null) this.x.funT()
if (this.x != null) this.x.funAny()
if (this.x != null) this.x.funNullableT()
if (this.x != null) this.x.funNullableAny()
if (this.x != null) this.x
if (x != null) this.x.equals(null)
if (x != null) this.x.propT
if (x != null) this.x.propAny
if (x != null) this.x.propNullableT
if (x != null) this.x.propNullableAny
if (x != null) this.x.funT()
if (x != null) this.x.funAny()
if (x != null) this.x.funNullableT()
if (x != null) this.x.funNullableAny()
if (x != null) this.x
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.equals(null)
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propNullableT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propNullableAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funNullableT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funNullableAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (this.y != null) this.y.equals(null)
if (this.y != null) this.y.propT
if (this.y != null) this.y.propAny
if (this.y != null) this.y.propNullableT
if (this.y != null) this.y.propNullableAny
if (this.y != null) this.y.funT()
if (this.y != null) this.y.funAny()
if (this.y != null) this.y.funNullableT()
if (this.y != null) this.y.funNullableAny()
if (this.y != null) this.y
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (y != null) this.y.equals(null)
if (y != null) this.y.propT
if (y != null) this.y.propAny
if (y != null) this.y.propNullableT
if (y != null) this.y.propNullableAny
if (y != null) this.y.funT()
if (y != null) this.y.funAny()
if (y != null) this.y.funNullableT()
if (y != null) this.y.funNullableAny()
if (y != null) this.y
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.equals(null)
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propNullableT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propNullableAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funNullableT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funNullableAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.equals(null)
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propT
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propAny
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableT
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableAny
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funT()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funAny()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableT()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableAny()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>
if (this.z != null) this.z.equals(null)
if (this.z != null) this.z.propT
if (this.z != null) this.z.propAny
if (this.z != null) this.z.propNullableT
if (this.z != null) this.z.propNullableAny
if (this.z != null) this.z.funT()
if (this.z != null) this.z.funAny()
if (this.z != null) this.z.funNullableT()
if (this.z != null) this.z.funNullableAny()
if (this.z != null) this.z
if (z != null) this.z.equals(null)
if (z != null) this.z.propT
if (z != null) this.z.propAny
if (z != null) this.z.propNullableT
if (z != null) this.z.propNullableAny
if (z != null) this.z.funT()
if (z != null) this.z.funAny()
if (z != null) this.z.funNullableT()
if (z != null) this.z.funNullableAny()
if (z != null) this.z
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.equals(null)
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propT
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propAny
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableT
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableAny
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funT()
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funAny()
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableT()
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableAny()
if (this.z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.equals(null)
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propT
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propAny
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableT
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableAny
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funT()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funAny()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableT()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableAny()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.equals(null)
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.propT
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.propAny
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.propNullableT
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.propNullableAny
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.funT()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.funAny()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.funNullableT()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z.funNullableAny()
if (z != null || <!SENSELESS_COMPARISON!>this.z != null<!>) this.z
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (this.u != null) this.u.equals(null)
if (this.u != null) this.u.propT
if (this.u != null) this.u.propAny
if (this.u != null) this.u.propNullableT
if (this.u != null) this.u.propNullableAny
if (this.u != null) this.u.funT()
if (this.u != null) this.u.funAny()
if (this.u != null) this.u.funNullableT()
if (this.u != null) this.u.funNullableAny()
if (this.u != null) this.u
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (u != null) this.u.equals(null)
if (u != null) this.u.propT
if (u != null) this.u.propAny
if (u != null) this.u.propNullableT
if (u != null) this.u.propNullableAny
if (u != null) this.u.funT()
if (u != null) this.u.funAny()
if (u != null) this.u.funNullableT()
if (u != null) this.u.funNullableAny()
if (u != null) this.u
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.equals(null)
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propNullableT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propNullableAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funNullableT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funNullableAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u
v = 0
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.equals(null)
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propNullableT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propNullableAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funNullableT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funNullableAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v
w = if (<!SENSELESS_COMPARISON!>null != null<!>) 10 else null
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.equals(null)
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.equals(null)
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propT
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propAny
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableT
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableAny
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funT()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funAny()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableT()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableAny()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.equals(null)
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.equals(null)
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propNullableT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propNullableAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funNullableT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funNullableAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w
s = null
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>.hashCode()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>
if (<!SENSELESS_COMPARISON!>s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing")!>s<!>
if (<!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing")!>s<!>
if (<!SENSELESS_COMPARISON!>s != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing")!>s<!>
if (<!SENSELESS_COMPARISON!>s != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) this.s
}
fun test() {
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.equals(null)
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propT
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propAny
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableT
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.propNullableAny
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funT()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funAny()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableT()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>.funNullableAny()
if (b != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Float? & kotlin.Float")!>b<!>
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.equals(null)
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propT
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propAny
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableT
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.propNullableAny
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funT()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funAny()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableT()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>.funNullableAny()
if (c != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>c<!>
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.equals(null)
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propT
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propAny
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableT
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.propNullableAny
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funT()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funAny()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableT()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>.funNullableAny()
if (d != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>d<!>
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.equals(null)
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propT
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propAny
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableT
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.propNullableAny
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funT()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funAny()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableT()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>.funNullableAny()
if (e != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>e<!>
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.equals(null)
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propT
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propAny
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableT
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.propNullableAny
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funT()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funAny()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableT()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>.funNullableAny()
if (f != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>f<!>
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.equals(null)
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propT
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propAny
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableT
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.propNullableAny
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funT()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funAny()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableT()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>.funNullableAny()
if (z != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>z<!>
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.equals(null)
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propNullableT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propNullableAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funNullableT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funNullableAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.equals(null)
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propT
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propAny
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propNullableT
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propNullableAny
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funT()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funAny()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funNullableT()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funNullableAny()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>
}
}
fun case_31(a: Case31) {
if (a.x !== null) a.x.equals(null)
if (a.x !== null) a.x.propT
if (a.x !== null) a.x.propAny
if (a.x !== null) a.x.propNullableT
if (a.x !== null) a.x.propNullableAny
if (a.x !== null) a.x.funT()
if (a.x !== null) a.x.funAny()
if (a.x !== null) a.x.funNullableT()
if (a.x !== null) a.x.funNullableAny()
if (a.x !== null) a.x
if (a.b !== null) a.b.equals(null)
if (a.b !== null) a.b.propT
if (a.b !== null) a.b.propAny
if (a.b !== null) a.b.propNullableT
if (a.b !== null) a.b.propNullableAny
if (a.b !== null) a.b.funT()
if (a.b !== null) a.b.funAny()
if (a.b !== null) a.b.funNullableT()
if (a.b !== null) a.b.funNullableAny()
if (a.b !== null) a.b
if (a.e !== null) a.e.equals(null)
if (a.e !== null) a.e.propT
if (a.e !== null) a.e.propAny
if (a.e !== null) a.e.propNullableT
if (a.e !== null) a.e.propNullableAny
if (a.e !== null) a.e.funT()
if (a.e !== null) a.e.funAny()
if (a.e !== null) a.e.funNullableT()
if (a.e !== null) a.e.funNullableAny()
if (a.e !== null) a.e
if (a.f !== null) a.f.equals(null)
if (a.f !== null) a.f.propT
if (a.f !== null) a.f.propAny
if (a.f !== null) a.f.propNullableT
if (a.f !== null) a.f.propNullableAny
if (a.f !== null) a.f.funT()
if (a.f !== null) a.f.funAny()
if (a.f !== null) a.f.funNullableT()
if (a.f !== null) a.f.funNullableAny()
if (a.f !== null) a.f
if (a.v != null) a.v.equals(null)
if (a.v != null) a.v.propT
if (a.v != null) a.v.propAny
if (a.v != null) a.v.propNullableT
if (a.v != null) a.v.propNullableAny
if (a.v != null) a.v.funT()
if (a.v != null) a.v.funAny()
if (a.v != null) a.v.funNullableT()
if (a.v != null) a.v.funNullableAny()
if (a.v != null) a.v
if (a.w != null) a.w.equals(null)
if (a.w != null) a.w.propT
if (a.w != null) a.w.propAny
if (a.w != null) a.w.propNullableT
if (a.w != null) a.w.propNullableAny
if (a.w != null) a.w.funT()
if (a.w != null) a.w.funAny()
if (a.w != null) a.w.funNullableT()
if (a.w != null) a.w.funNullableAny()
if (a.w != null) a.w
if (a.s != null) a.s.equals(null)
if (a.s != null) a.s.propT
if (a.s != null) a.s.propAny
if (a.s != null) a.s.propNullableT
if (a.s != null) a.s.propNullableAny
if (a.s != null) a.s.funT()
if (a.s != null) a.s.funAny()
if (a.s != null) a.s.funNullableT()
if (a.s != null) a.s.funNullableAny()
if (a.s != null) a.s
if (Case31.A.b != null) Case31.A.b.equals(null)
if (Case31.A.b != null) Case31.A.b.propT
if (Case31.A.b != null) Case31.A.b.propAny
if (Case31.A.b != null) Case31.A.b.propNullableT
if (Case31.A.b != null) Case31.A.b.propNullableAny
if (Case31.A.b != null) Case31.A.b.funT()
if (Case31.A.b != null) Case31.A.b.funAny()
if (Case31.A.b != null) Case31.A.b.funNullableT()
if (Case31.A.b != null) Case31.A.b.funNullableAny()
if (Case31.A.b != null) Case31.A.b
if (Case31.A.e != null) Case31.A.e.equals(null)
if (Case31.A.e != null) Case31.A.e.propT
if (Case31.A.e != null) Case31.A.e.propAny
if (Case31.A.e != null) Case31.A.e.propNullableT
if (Case31.A.e != null) Case31.A.e.propNullableAny
if (Case31.A.e != null) Case31.A.e.funT()
if (Case31.A.e != null) Case31.A.e.funAny()
if (Case31.A.e != null) Case31.A.e.funNullableT()
if (Case31.A.e != null) Case31.A.e.funNullableAny()
if (Case31.A.e != null) Case31.A.e
if (Case31.A.f != null) Case31.A.f.equals(null)
if (Case31.A.f != null) Case31.A.f.propT
if (Case31.A.f != null) Case31.A.f.propAny
if (Case31.A.f != null) Case31.A.f.propNullableT
if (Case31.A.f != null) Case31.A.f.propNullableAny
if (Case31.A.f != null) Case31.A.f.funT()
if (Case31.A.f != null) Case31.A.f.funAny()
if (Case31.A.f != null) Case31.A.f.funNullableT()
if (Case31.A.f != null) Case31.A.f.funNullableAny()
if (Case31.A.f != null) Case31.A.f
}
// TESTCASE NUMBER: 32
object Case32 {
val x: Char? = '.'
private val y: Unit? = kotlin.Unit
public val u: String? = "..."
val s: Any?
val v: Int?
val w: Number?
val t: String? = if (u != null) this.u else null
init {
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (this.x != null) this.x.equals(null)
if (this.x != null) this.x.propT
if (this.x != null) this.x.propAny
if (this.x != null) this.x.propNullableT
if (this.x != null) this.x.propNullableAny
if (this.x != null) this.x.funT()
if (this.x != null) this.x.funAny()
if (this.x != null) this.x.funNullableT()
if (this.x != null) this.x.funNullableAny()
if (this.x != null) this.x
if (x != null) this.x.equals(null)
if (x != null) this.x.propT
if (x != null) this.x.propAny
if (x != null) this.x.propNullableT
if (x != null) this.x.propNullableAny
if (x != null) this.x.funT()
if (x != null) this.x.funAny()
if (x != null) this.x.funNullableT()
if (x != null) this.x.funNullableAny()
if (x != null) this.x
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (this.x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.equals(null)
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propNullableT
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.propNullableAny
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funNullableT()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x.funNullableAny()
if (x != null || <!SENSELESS_COMPARISON!>this.x != null<!>) this.x
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (this.y != null) this.y.equals(null)
if (this.y != null) this.y.propT
if (this.y != null) this.y.propAny
if (this.y != null) this.y.propNullableT
if (this.y != null) this.y.propNullableAny
if (this.y != null) this.y.funT()
if (this.y != null) this.y.funAny()
if (this.y != null) this.y.funNullableT()
if (this.y != null) this.y.funNullableAny()
if (this.y != null) this.y
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (this.y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (y != null) this.y.equals(null)
if (y != null) this.y.propT
if (y != null) this.y.propAny
if (y != null) this.y.propNullableT
if (y != null) this.y.propNullableAny
if (y != null) this.y.funT()
if (y != null) this.y.funAny()
if (y != null) this.y.funNullableT()
if (y != null) this.y.funNullableAny()
if (y != null) this.y
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.equals(null)
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propNullableT
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.propNullableAny
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funNullableT()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y.funNullableAny()
if (y != null || <!SENSELESS_COMPARISON!>this.y != null<!>) this.y
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (this.u != null) this.u.equals(null)
if (this.u != null) this.u.propT
if (this.u != null) this.u.propAny
if (this.u != null) this.u.propNullableT
if (this.u != null) this.u.propNullableAny
if (this.u != null) this.u.funT()
if (this.u != null) this.u.funAny()
if (this.u != null) this.u.funNullableT()
if (this.u != null) this.u.funNullableAny()
if (this.u != null) this.u
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (this.u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (u != null) this.u.equals(null)
if (u != null) this.u.propT
if (u != null) this.u.propAny
if (u != null) this.u.propNullableT
if (u != null) this.u.propNullableAny
if (u != null) this.u.funT()
if (u != null) this.u.funAny()
if (u != null) this.u.funNullableT()
if (u != null) this.u.funNullableAny()
if (u != null) this.u
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.equals(null)
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propNullableT
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.propNullableAny
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funNullableT()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u.funNullableAny()
if (u != null || <!SENSELESS_COMPARISON!>this.u != null<!>) this.u
v = 0
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (<!SENSELESS_COMPARISON!>v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (<!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.equals(null)
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propNullableT
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.propNullableAny
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funNullableT()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v.funNullableAny()
if (<!SENSELESS_COMPARISON!>v != null<!> || <!SENSELESS_COMPARISON!>this.v != null<!>) this.v
w = if (<!SENSELESS_COMPARISON!>null != null<!>) 10 else null
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.equals(null)
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.equals(null)
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propT
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propAny
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableT
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableAny
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funT()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funAny()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableT()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableAny()
if (this.w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.equals(null)
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.propNullableAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>.funNullableAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Int")!>w<!>
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.equals(null)
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propNullableT
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.propNullableAny
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funNullableT()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w.funNullableAny()
if (w != null || <!SENSELESS_COMPARISON!>this.w != null<!>) this.w
s = null
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>.hashCode()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing?")!>s<!>
if (<!SENSELESS_COMPARISON!>s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing")!>s<!>
if (<!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing")!>s<!>
if (<!SENSELESS_COMPARISON!>s != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Nothing")!>s<!>
if (<!SENSELESS_COMPARISON!>s != null<!> || <!SENSELESS_COMPARISON!>this.s != null<!>) this.s
}
fun test() {
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.equals(null)
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableT
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.propNullableAny
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableT()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>.funNullableAny()
if (x != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Char? & kotlin.Char")!>x<!>
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.equals(null)
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableT
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.propNullableAny
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableT()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>.funNullableAny()
if (y != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Unit? & kotlin.Unit")!>y<!>
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.equals(null)
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableT
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.propNullableAny
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableT()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>.funNullableAny()
if (u != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.String? & kotlin.String")!>u<!>
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.equals(null)
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propT
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propAny
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableT
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.propNullableAny
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funT()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funAny()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableT()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>.funNullableAny()
if (v != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>v<!>
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.equals(null)
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propNullableT
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.propNullableAny
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funNullableT()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>.funNullableAny()
if (w != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Number? & kotlin.Number")!>w<!>
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.equals(null)
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propT
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propAny
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propNullableT
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.propNullableAny
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funT()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funAny()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funNullableT()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>.funNullableAny()
if (s != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Any? & kotlin.Any")!>s<!>
}
}
fun case_32(a: Case32) {
if (a.x != null) a.x.equals(null)
if (a.x != null) a.x.propT
if (a.x != null) a.x.propAny
if (a.x != null) a.x.propNullableT
if (a.x != null) a.x.propNullableAny
if (a.x != null) a.x.funT()
if (a.x != null) a.x.funAny()
if (a.x != null) a.x.funNullableT()
if (a.x != null) a.x.funNullableAny()
if (a.x != null) a.x
if (a.v != null) a.v.equals(null)
if (a.v != null) a.v.propT
if (a.v != null) a.v.propAny
if (a.v != null) a.v.propNullableT
if (a.v != null) a.v.propNullableAny
if (a.v != null) a.v.funT()
if (a.v != null) a.v.funAny()
if (a.v != null) a.v.funNullableT()
if (a.v != null) a.v.funNullableAny()
if (a.v != null) a.v
if (a.w != null) a.w.equals(null)
if (a.w != null) a.w.propT
if (a.w != null) a.w.propAny
if (a.w != null) a.w.propNullableT
if (a.w != null) a.w.propNullableAny
if (a.w != null) a.w.funT()
if (a.w != null) a.w.funAny()
if (a.w != null) a.w.funNullableT()
if (a.w != null) a.w.funNullableAny()
if (a.w != null) a.w
if (a.s != null) a.s.equals(null)
if (a.s != null) a.s.propT
if (a.s != null) a.s.propAny
if (a.s != null) a.s.propNullableT
if (a.s != null) a.s.propNullableAny
if (a.s != null) a.s.funT()
if (a.s != null) a.s.funAny()
if (a.s != null) a.s.funNullableT()
if (a.s != null) a.s.funNullableAny()
if (a.s != null) a.s
}
// TESTCASE NUMBER: 33
fun case_33(a: Int?, b: Int = if (a != null) <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int? & kotlin.Int")!>a<!> else 0) {
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>a<!>
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>b<!>.equals(null)
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>b<!>.propT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>b<!>.propAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>b<!>.propNullableT
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>b<!>.propNullableAny
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>b<!>.funT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>b<!>.funAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>b<!>.funNullableT()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>b<!>.funNullableAny()
<!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int")!>b<!>
}
| 181 | null | 5771 | 49,172 | 33eb9cef3d146062c103f9853d772f0a1da0450e | 288,178 | kotlin | Apache License 2.0 |
syftlib/src/test/java/fl/wearable/autosport/integration/SpeedIntegrationTest.kt | FL-Wearable | 284,693,631 | false | null | package fl.wearable.autosport.integration
import android.net.NetworkCapabilities
import com.nhaarman.mockitokotlin2.any
import com.nhaarman.mockitokotlin2.never
import com.nhaarman.mockitokotlin2.spy
import com.nhaarman.mockitokotlin2.verify
import org.junit.Test
import fl.wearable.autosport.Syft
import fl.wearable.autosport.common.AbstractSyftWorkerTest
import fl.wearable.autosport.domain.SyftConfiguration
import fl.wearable.autosport.execution.JobStatusSubscriber
import fl.wearable.autosport.integration.clients.HttpClientMock
import fl.wearable.autosport.integration.clients.SocketClientMock
import fl.wearable.autosport.integration.execution.ShadowPlan
import org.robolectric.annotation.Config
@ExperimentalUnsignedTypes
class SpeedIntegrationTest : AbstractSyftWorkerTest() {
@Test
@Config(shadows = [ShadowPlan::class])
fun `Test workflow with cycle rejected`() {
val socketClient = SocketClientMock(
authenticateSuccess = true,
cycleSuccess = false
)
val httpClient = HttpClientMock(
pingSuccess = true, downloadSpeedSuccess = true,
uploadSuccess = true, downloadPlanSuccess = true, downloadModelSuccess = true
)
val syftConfiguration = SyftConfiguration(
context,
networkingSchedulers,
computeSchedulers,
context.filesDir,
true,
batteryCheckEnabled = true,
networkConstraints = networkConstraints,
transportMedium = NetworkCapabilities.TRANSPORT_WIFI,
cacheTimeOut = 0,
maxConcurrentJobs = 1,
socketClient = socketClient.getMockedClient(),
httpClient = httpClient.getMockedClient(),
messagingClient = SyftConfiguration.NetworkingClients.SOCKET
)
val syftWorker = Syft.getInstance(syftConfiguration)
val job = syftWorker.newJob("test", "1")
val jobStatusSubscriber = spy<JobStatusSubscriber>()
job.start(jobStatusSubscriber)
verify(jobStatusSubscriber).onRejected(any())
syftWorker.dispose()
verify(jobStatusSubscriber).onComplete()
}
@Test
@Config(shadows = [ShadowPlan::class])
fun `Test workflow with ping error`() {
val socketClient = SocketClientMock(
authenticateSuccess = true,
cycleSuccess = true
)
val httpClient = HttpClientMock(
pingSuccess = false, downloadSpeedSuccess = true,
uploadSuccess = true, downloadPlanSuccess = true, downloadModelSuccess = true
)
val syftConfiguration = SyftConfiguration(
context,
networkingSchedulers,
computeSchedulers,
context.filesDir,
true,
batteryCheckEnabled = true,
networkConstraints = networkConstraints,
transportMedium = NetworkCapabilities.TRANSPORT_WIFI,
cacheTimeOut = 0,
maxConcurrentJobs = 1,
socketClient = socketClient.getMockedClient(),
httpClient = httpClient.getMockedClient(),
messagingClient = SyftConfiguration.NetworkingClients.SOCKET
)
val syftWorker = Syft.getInstance(syftConfiguration)
val job = syftWorker.newJob("test", "1")
val jobStatusSubscriber = spy<JobStatusSubscriber>()
job.start(jobStatusSubscriber)
verify(jobStatusSubscriber).onError(any())
syftWorker.dispose()
verify(jobStatusSubscriber, never()).onComplete()
}
@Test
@Config(shadows = [ShadowPlan::class])
fun `Test workflow with download speed test error`() {
val socketClient = SocketClientMock(
authenticateSuccess = true,
cycleSuccess = true
)
val httpClient = HttpClientMock(
pingSuccess = true, downloadSpeedSuccess = false,
uploadSuccess = true, downloadPlanSuccess = true, downloadModelSuccess = true
)
val syftConfiguration = SyftConfiguration(
context,
networkingSchedulers,
computeSchedulers,
context.filesDir,
true,
batteryCheckEnabled = true,
networkConstraints = networkConstraints,
transportMedium = NetworkCapabilities.TRANSPORT_WIFI,
cacheTimeOut = 0,
maxConcurrentJobs = 1,
socketClient = socketClient.getMockedClient(),
httpClient = httpClient.getMockedClient(),
messagingClient = SyftConfiguration.NetworkingClients.SOCKET
)
val syftWorker = Syft.getInstance(syftConfiguration)
val job = syftWorker.newJob("test", "1")
val jobStatusSubscriber = spy<JobStatusSubscriber>()
job.start(jobStatusSubscriber)
verify(jobStatusSubscriber).onError(any())
syftWorker.dispose()
verify(jobStatusSubscriber, never()).onComplete()
}
@Test
@Config(shadows = [ShadowPlan::class])
fun `Test workflow with upload speed test error`() {
val socketClient = SocketClientMock(
authenticateSuccess = true,
cycleSuccess = true
)
val httpClient = HttpClientMock(
pingSuccess = true, downloadSpeedSuccess = true,
uploadSuccess = false, downloadPlanSuccess = true, downloadModelSuccess = true
)
val syftConfiguration = SyftConfiguration(
context,
networkingSchedulers,
computeSchedulers,
context.filesDir,
true,
batteryCheckEnabled = true,
networkConstraints = networkConstraints,
transportMedium = NetworkCapabilities.TRANSPORT_WIFI,
cacheTimeOut = 0,
maxConcurrentJobs = 1,
socketClient = socketClient.getMockedClient(),
httpClient = httpClient.getMockedClient(),
messagingClient = SyftConfiguration.NetworkingClients.SOCKET
)
val syftWorker = Syft.getInstance(syftConfiguration)
val job = syftWorker.newJob("test", "1")
val jobStatusSubscriber = spy<JobStatusSubscriber>()
job.start(jobStatusSubscriber)
verify(jobStatusSubscriber).onError(any())
syftWorker.dispose()
verify(jobStatusSubscriber, never()).onComplete()
}
} | 0 | Kotlin | 1 | 3 | 276aee68722432afb2264a3aa27b8ea941873e4f | 6,376 | Trainer | Apache License 2.0 |
compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirBodyResolveTransformer.kt | walltz556 | 215,167,660 | false | null | /*
* Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.fir.resolve.transformers
import org.jetbrains.kotlin.contracts.description.InvocationKind
import org.jetbrains.kotlin.fir.*
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
import org.jetbrains.kotlin.fir.declarations.impl.FirValueParameterImpl
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition
import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyExpressionBlock
import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionWithSmartcastImpl
import org.jetbrains.kotlin.fir.references.FirExplicitThisReference
import org.jetbrains.kotlin.fir.references.FirSimpleNamedReference
import org.jetbrains.kotlin.fir.resolve.*
import org.jetbrains.kotlin.fir.resolve.calls.*
import org.jetbrains.kotlin.fir.resolve.dfa.DataFlowInferenceContext
import org.jetbrains.kotlin.fir.resolve.dfa.FirDataFlowAnalyzer
import org.jetbrains.kotlin.fir.resolve.inference.FirCallCompleter
import org.jetbrains.kotlin.fir.scopes.FirScope
import org.jetbrains.kotlin.fir.scopes.addImportingScopes
import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope
import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType
import org.jetbrains.kotlin.fir.symbols.*
import org.jetbrains.kotlin.fir.types.*
import org.jetbrains.kotlin.fir.types.impl.*
import org.jetbrains.kotlin.fir.visitors.CompositeTransformResult
import org.jetbrains.kotlin.fir.visitors.FirTransformer
import org.jetbrains.kotlin.fir.visitors.compose
import org.jetbrains.kotlin.ir.expressions.IrConstKind
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.types.model.KotlinTypeMarker
import org.jetbrains.kotlin.types.model.SimpleTypeMarker
import org.jetbrains.kotlin.types.model.TypeConstructorMarker
import org.jetbrains.kotlin.types.model.TypeSystemInferenceExtensionContextDelegate
import org.jetbrains.kotlin.utils.addIfNotNull
open class FirBodyResolveTransformer(
final override val session: FirSession,
phase: FirResolvePhase,
implicitTypeOnly: Boolean,
final override val scopeSession: ScopeSession = ScopeSession()
) : FirAbstractPhaseTransformer<Any?>(phase), BodyResolveComponents {
var implicitTypeOnly: Boolean = implicitTypeOnly
private set
final override val returnTypeCalculator: ReturnTypeCalculator = ReturnTypeCalculatorWithJump(session, scopeSession)
final override val noExpectedType = FirImplicitTypeRefImpl(null)
private inline val builtinTypes: BuiltinTypes get() = session.builtinTypes
final override val symbolProvider = session.service<FirSymbolProvider>()
private var packageFqName = FqName.ROOT
final override lateinit var file: FirFile
private set
private var _container: FirDeclaration? = null
final override var container: FirDeclaration
get() = _container!!
private set(value) {
_container = value
}
private val localScopes = mutableListOf<FirLocalScope>()
private val topLevelScopes = mutableListOf<FirScope>()
final override val implicitReceiverStack: ImplicitReceiverStackImpl = ImplicitReceiverStackImpl()
final override val inferenceComponents = inferenceComponents(session, returnTypeCalculator, scopeSession)
final override val samResolver: FirSamResolver = FirSamResolverImpl(session, scopeSession)
private var primaryConstructorParametersScope: FirLocalScope? = null
private val callCompleter: FirCallCompleter = FirCallCompleter(this)
private val qualifiedResolver: FirQualifiedNameResolver = FirQualifiedNameResolver(this)
final override val resolutionStageRunner: ResolutionStageRunner = ResolutionStageRunner(inferenceComponents)
private val callResolver: FirCallResolver = FirCallResolver(
this,
topLevelScopes,
localScopes,
implicitReceiverStack,
qualifiedResolver
)
private val syntheticCallGenerator: FirSyntheticCallGenerator = FirSyntheticCallGenerator(this)
private val dataFlowAnalyzer: FirDataFlowAnalyzer = FirDataFlowAnalyzer(this)
override val <D> AbstractFirBasedSymbol<D>.phasedFir: D where D : FirDeclaration, D : FirSymbolOwner<D>
get() {
val requiredPhase = transformerPhase.prev
return phasedFir(session, requiredPhase)
}
override fun transformFile(file: FirFile, data: Any?): CompositeTransformResult<FirFile> {
packageFqName = file.packageFqName
this.file = file
return withScopeCleanup(topLevelScopes) {
topLevelScopes.addImportingScopes(file, session, scopeSession)
super.transformFile(file, data)
}
}
override fun <E : FirElement> transformElement(element: E, data: Any?): CompositeTransformResult<E> {
@Suppress("UNCHECKED_CAST")
return (element.transformChildren(this, data) as E).compose()
}
override fun transformConstructor(constructor: FirConstructor, data: Any?): CompositeTransformResult<FirDeclaration> {
if (implicitTypeOnly) return constructor.compose()
return transformFunction(constructor, data)
}
override fun transformAnonymousInitializer(
anonymousInitializer: FirAnonymousInitializer,
data: Any?
): CompositeTransformResult<FirDeclaration> {
if (implicitTypeOnly) return anonymousInitializer.compose()
return withScopeCleanup(localScopes) {
dataFlowAnalyzer.enterInitBlock(anonymousInitializer)
localScopes.addIfNotNull(primaryConstructorParametersScope)
transformDeclaration(anonymousInitializer, data).also {
dataFlowAnalyzer.exitInitBlock(it.single as FirAnonymousInitializer)
}
}
}
override fun transformImplicitTypeRef(implicitTypeRef: FirImplicitTypeRef, data: Any?): CompositeTransformResult<FirTypeRef> {
if (data == null)
return implicitTypeRef.compose()
require(data is FirTypeRef)
return data.compose()
}
override fun transformValueParameter(valueParameter: FirValueParameter, data: Any?): CompositeTransformResult<FirDeclaration> {
localScopes.lastOrNull()?.storeDeclaration(valueParameter)
if (valueParameter.returnTypeRef is FirImplicitTypeRef) {
valueParameter.resolvePhase = transformerPhase
return valueParameter.compose() // TODO
}
return transformDeclaration(valueParameter, valueParameter.returnTypeRef)
}
override fun transformRegularClass(regularClass: FirRegularClass, data: Any?): CompositeTransformResult<FirDeclaration> {
val oldConstructorScope = primaryConstructorParametersScope
primaryConstructorParametersScope = null
val type = regularClass.defaultType()
val result = withLabelAndReceiverType(regularClass.name, regularClass, type) {
val constructor = regularClass.declarations.firstOrNull() as? FirConstructor
if (constructor?.isPrimary == true) {
primaryConstructorParametersScope = FirLocalScope().apply {
constructor.valueParameters.forEach { this.storeDeclaration(it) }
}
}
transformDeclaration(regularClass, data)
}
primaryConstructorParametersScope = oldConstructorScope
return result
}
override fun transformUncheckedNotNullCast(
uncheckedNotNullCast: FirUncheckedNotNullCast,
data: Any?
): CompositeTransformResult<FirStatement> {
val notNullCast = transformExpression(uncheckedNotNullCast, data).single as FirUncheckedNotNullCast
val resultType = notNullCast.expression.resultType
notNullCast.resultType =
resultType.withReplacedConeType(resultType.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NOT_NULL))
return notNullCast.compose()
}
override fun transformTypeOperatorCall(typeOperatorCall: FirTypeOperatorCall, data: Any?): CompositeTransformResult<FirStatement> {
val symbolProvider = session.service<FirSymbolProvider>()
val resolved = transformExpression(typeOperatorCall, data).single
when ((resolved as FirTypeOperatorCall).operation) {
FirOperation.IS, FirOperation.NOT_IS -> {
resolved.resultType = FirResolvedTypeRefImpl(
null,
StandardClassIds.Boolean(symbolProvider).constructType(emptyArray(), isNullable = false),
emptyList()
)
}
FirOperation.AS -> {
resolved.resultType = resolved.conversionTypeRef
}
FirOperation.SAFE_AS -> {
resolved.resultType =
resolved.conversionTypeRef.withReplacedConeType(
resolved.conversionTypeRef.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NULLABLE)
)
}
else -> error("Unknown type operator")
}
dataFlowAnalyzer.exitTypeOperatorCall(typeOperatorCall)
return resolved.compose()
}
override fun transformQualifiedAccessExpression(
qualifiedAccessExpression: FirQualifiedAccessExpression,
data: Any?
): CompositeTransformResult<FirStatement> {
var result = when (val callee = qualifiedAccessExpression.calleeReference) {
is FirExplicitThisReference -> {
val labelName = callee.labelName
val implicitReceiver = implicitReceiverStack[labelName]
callee.boundSymbol = implicitReceiver?.boundSymbol
qualifiedAccessExpression.resultType = FirResolvedTypeRefImpl(
null, implicitReceiver?.type ?: ConeKotlinErrorType("Unresolved this@$labelName"),
emptyList()
)
qualifiedAccessExpression
}
is FirSuperReference -> {
if (callee.superTypeRef is FirResolvedTypeRef) {
qualifiedAccessExpression.resultType = callee.superTypeRef
} else {
val superTypeRef = implicitReceiverStack.lastDispatchReceiver()
?.boundSymbol?.phasedFir?.superTypeRefs?.firstOrNull()
?: FirErrorTypeRefImpl(qualifiedAccessExpression.psi, "No super type")
qualifiedAccessExpression.resultType = superTypeRef
callee.replaceSuperTypeRef(superTypeRef)
}
qualifiedAccessExpression
}
is FirDelegateFieldReference -> {
val delegateFieldSymbol = callee.resolvedSymbol
qualifiedAccessExpression.resultType = delegateFieldSymbol.delegate.typeRef
qualifiedAccessExpression
}
is FirResolvedCallableReference -> {
if (qualifiedAccessExpression.typeRef !is FirResolvedTypeRef) {
storeTypeFromCallee(qualifiedAccessExpression)
}
qualifiedAccessExpression
}
else -> {
val transformedCallee = callResolver.resolveVariableAccessAndSelectCandidate(qualifiedAccessExpression, file)
// NB: here we can get raw expression because of dropped qualifiers (see transform callee),
// so candidate existence must be checked before calling completion
if (transformedCallee is FirQualifiedAccessExpression && transformedCallee.candidate() != null) {
callCompleter.completeCall(transformedCallee, data as? FirTypeRef)
} else {
transformedCallee
}
}
}
if (result is FirQualifiedAccessExpression) {
result = transformQualifiedAccessUsingSmartcastInfo(result)
dataFlowAnalyzer.exitQualifiedAccessExpression(result)
}
return result.compose()
}
private fun transformQualifiedAccessUsingSmartcastInfo(qualifiedAccessExpression: FirQualifiedAccessExpression): FirQualifiedAccessExpression {
val typesFromSmartCast = dataFlowAnalyzer.getTypeUsingSmartcastInfo(qualifiedAccessExpression) ?: return qualifiedAccessExpression
val allTypes = typesFromSmartCast.toMutableList().also {
it += qualifiedAccessExpression.resultType.coneTypeUnsafe<ConeKotlinType>()
}
val intersectedType = ConeTypeIntersector.intersectTypes(inferenceComponents.ctx as ConeInferenceContext, allTypes)
// TODO: add check that intersectedType is not equal to original type
return FirExpressionWithSmartcastImpl(qualifiedAccessExpression, typesFromSmartCast).also {
it.resultType = FirResolvedTypeRefImpl(qualifiedAccessExpression.resultType.psi, intersectedType, qualifiedAccessExpression.resultType.annotations)
}
}
override fun transformVariableAssignment(
variableAssignment: FirVariableAssignment,
data: Any?
): CompositeTransformResult<FirStatement> {
// val resolvedAssignment = transformCallee(variableAssignment)
val resolvedAssignment = callResolver.resolveVariableAccessAndSelectCandidate(variableAssignment, file)
val result = if (resolvedAssignment is FirVariableAssignment) {
val completeAssignment = callCompleter.completeCall(resolvedAssignment, noExpectedType)
val expectedType = typeFromCallee(completeAssignment)
completeAssignment.transformRValue(this, expectedType)
} else {
// This can happen in erroneous code only
resolvedAssignment
}
// TODO: maybe replace with FirAbstractAssignment for performance?
(result as? FirVariableAssignment)?.let { dataFlowAnalyzer.exitVariableAssignment(it) }
return result.compose()
}
override fun transformAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Any?): CompositeTransformResult<FirDeclaration> {
return when (data) {
null -> {
anonymousFunction.compose()
}
is LambdaResolution -> {
transformAnonymousFunctionWithLambdaResolution(anonymousFunction, data).compose()
}
is FirTypeRef -> {
val resolvedLambdaAtom = (data as? FirResolvedTypeRef)?.let {
extractLambdaInfoFromFunctionalType(
it.type, it, anonymousFunction
)
}
var af = anonymousFunction
val valueParameters =
if (resolvedLambdaAtom == null) af.valueParameters
else {
val singleParameterType = resolvedLambdaAtom.parameters.singleOrNull()
val itParam = when {
af.valueParameters.isEmpty() && singleParameterType != null ->
FirValueParameterImpl(
session,
null,
Name.identifier("it"),
FirResolvedTypeRefImpl(null, singleParameterType, emptyList()),
defaultValue = null,
isCrossinline = false,
isNoinline = false,
isVararg = false
)
else -> null
}
if (itParam != null) {
listOf(itParam)
} else {
af.valueParameters.mapIndexed { index, param ->
if (param.returnTypeRef is FirResolvedTypeRef) {
param
} else {
param.transformReturnTypeRef(
StoreType,
param.returnTypeRef.resolvedTypeFromPrototype(
resolvedLambdaAtom.parameters[index]
)
)
param
}
}
}
}
val returnTypeRefFromResolvedAtom = resolvedLambdaAtom?.returnType?.let { af.returnTypeRef.resolvedTypeFromPrototype(it) }
af = af.copy(
receiverTypeRef = af.receiverTypeRef?.takeIf { it !is FirImplicitTypeRef }
?: resolvedLambdaAtom?.receiver?.let { af.receiverTypeRef?.resolvedTypeFromPrototype(it) },
valueParameters = valueParameters,
returnTypeRef = (af.returnTypeRef as? FirResolvedTypeRef)
?: returnTypeRefFromResolvedAtom
?: af.returnTypeRef
)
af = af.transformValueParameters(ImplicitToErrorTypeTransformer, null) as FirAnonymousFunction
val bodyExpectedType = returnTypeRefFromResolvedAtom ?: data
af = transformFunction(af, bodyExpectedType).single as FirAnonymousFunction
af = af.copy(
returnTypeRef = af.body?.resultType ?: FirErrorTypeRefImpl(af.psi, "No result type for lambda")
)
af.replaceTypeRef(af.constructFunctionalTypeRef(session))
af.compose()
}
else -> {
transformFunction(anonymousFunction, data)
}
}
}
private object ImplicitToErrorTypeTransformer : FirTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
return element.compose()
}
override fun transformValueParameter(valueParameter: FirValueParameter, data: Nothing?): CompositeTransformResult<FirDeclaration> {
if (valueParameter.returnTypeRef is FirImplicitTypeRef) {
valueParameter.transformReturnTypeRef(
StoreType,
valueParameter.returnTypeRef.resolvedTypeFromPrototype(ConeKotlinErrorType("No type for parameter"))
)
}
return valueParameter.compose()
}
}
private fun transformAnonymousFunctionWithLambdaResolution(
anonymousFunction: FirAnonymousFunction, lambdaResolution: LambdaResolution
): FirAnonymousFunction {
val receiverTypeRef = anonymousFunction.receiverTypeRef
fun transform(): FirAnonymousFunction {
val expectedReturnType =
lambdaResolution.expectedReturnTypeRef ?: anonymousFunction.returnTypeRef.takeUnless { it is FirImplicitTypeRef }
val result = transformFunction(anonymousFunction, expectedReturnType).single as FirAnonymousFunction
val body = result.body
return if (result.returnTypeRef is FirImplicitTypeRef && body != null) {
result.transformReturnTypeRef(this, body.resultType)
result
} else {
result
}
}
val label = anonymousFunction.label
return if (label != null && receiverTypeRef != null) {
withLabelAndReceiverType(Name.identifier(label.name), anonymousFunction, receiverTypeRef.coneTypeUnsafe()) {
transform()
}
} else {
transform()
}
}
data class LambdaResolution(val expectedReturnTypeRef: FirResolvedTypeRef?)
override fun transformCatch(catch: FirCatch, data: Any?): CompositeTransformResult<FirCatch> {
dataFlowAnalyzer.enterCatchClause(catch)
return withScopeCleanup(localScopes) {
localScopes += FirLocalScope()
catch.transformParameter(this, noExpectedType)
catch.transformBlock(this, null)
}.also { dataFlowAnalyzer.exitCatchClause(it) }.compose()
}
override fun transformTryExpression(tryExpression: FirTryExpression, data: Any?): CompositeTransformResult<FirStatement> {
if (tryExpression.calleeReference is FirResolvedCallableReference && tryExpression.resultType !is FirImplicitTypeRef) {
return tryExpression.compose()
}
dataFlowAnalyzer.enterTryExpression(tryExpression)
tryExpression.transformTryBlock(this, null)
dataFlowAnalyzer.exitTryMainBlock(tryExpression)
tryExpression.transformCatches(this, null)
@Suppress("NAME_SHADOWING")
var result = syntheticCallGenerator.generateCalleeForTryExpression(tryExpression)?.let {
val expectedTypeRef = data as FirTypeRef?
callCompleter.completeCall(it, expectedTypeRef)
} ?: run {
tryExpression.resultType = FirErrorTypeRefImpl(null, "")
tryExpression
}
result = if (result.finallyBlock != null) {
result.also(dataFlowAnalyzer::enterFinallyBlock)
.transformFinallyBlock(this, noExpectedType)
.also(dataFlowAnalyzer::exitFinallyBlock)
} else {
result
}
dataFlowAnalyzer.exitTryExpression(result)
return result.compose()
}
override fun transformFunctionCall(functionCall: FirFunctionCall, data: Any?): CompositeTransformResult<FirStatement> {
dataFlowAnalyzer.enterFunctionCall(functionCall)
if (functionCall.calleeReference is FirResolvedCallableReference && functionCall.resultType is FirImplicitTypeRef) {
storeTypeFromCallee(functionCall)
}
if (functionCall.calleeReference !is FirSimpleNamedReference) return functionCall.compose()
functionCall.transform<FirFunctionCall, InvocationKind?>(InvocationKindTransformer, null)
val expectedTypeRef = data as FirTypeRef?
val completeInference =
try {
val initialExplicitReceiver = functionCall.explicitReceiver
val resultExpression = callResolver.resolveCallAndSelectCandidate(functionCall, expectedTypeRef, file)
val resultExplicitReceiver = resultExpression.explicitReceiver
if (initialExplicitReceiver !== resultExplicitReceiver && resultExplicitReceiver is FirQualifiedAccess) {
// name.invoke() case
callCompleter.completeCall(resultExplicitReceiver, noExpectedType)
}
callCompleter.completeCall(resultExpression, expectedTypeRef)
} catch (e: Throwable) {
throw RuntimeException("While resolving call ${functionCall.render()}", e)
}
dataFlowAnalyzer.exitFunctionCall(completeInference)
return completeInference.compose()
}
// override fun transformNamedReference(namedReference: FirNamedReference, data: Any?): CompositeTransformResult<FirNamedReference> {
// if (namedReference is FirErrorNamedReference || namedReference is FirResolvedCallableReference) return namedReference.compose()
// val referents = data as? List<ConeCallableSymbol> ?: return namedReference.compose()
// return createResolvedNamedReference(namedReference, referents).compose()
// }
override fun transformBlock(block: FirBlock, data: Any?): CompositeTransformResult<FirStatement> {
dataFlowAnalyzer.enterBlock(block)
@Suppress("NAME_SHADOWING")
val block = block.transformChildren(this, data) as FirBlock
val statement = block.statements.lastOrNull()
val resultExpression = when (statement) {
is FirReturnExpression -> statement.result
is FirExpression -> statement
else -> null
}
block.resultType = if (resultExpression == null) {
FirImplicitUnitTypeRef(block.psi)
} else {
(resultExpression.resultType as? FirResolvedTypeRef) ?: FirErrorTypeRefImpl(null, "No type for block")
}
dataFlowAnalyzer.exitBlock(block)
return block.compose()
}
override fun <E : FirTargetElement> transformJump(jump: FirJump<E>, data: Any?): CompositeTransformResult<FirStatement> {
val result = transformExpression(jump, data)
dataFlowAnalyzer.exitJump(jump)
return result
}
override fun transformThrowExpression(throwExpression: FirThrowExpression, data: Any?): CompositeTransformResult<FirStatement> {
return transformExpression(throwExpression, data).also {
dataFlowAnalyzer.exitThrowExceptionNode(it.single as FirThrowExpression)
}
}
override fun transformWhenExpression(whenExpression: FirWhenExpression, data: Any?): CompositeTransformResult<FirStatement> {
if (whenExpression.calleeReference is FirResolvedCallableReference && whenExpression.resultType !is FirImplicitTypeRef) {
return whenExpression.compose()
}
dataFlowAnalyzer.enterWhenExpression(whenExpression)
return withScopeCleanup(localScopes) with@{
if (whenExpression.subjectVariable != null) {
localScopes += FirLocalScope()
}
whenExpression.transformSubject(this, noExpectedType)
if (whenExpression.isOneBranch()) {
whenExpression.transformBranches(this, noExpectedType)
whenExpression.resultType = whenExpression.branches.first().result.resultType
dataFlowAnalyzer.exitWhenExpression(whenExpression)
return@with whenExpression.compose()
}
whenExpression.transformBranches(this, null)
@Suppress("NAME_SHADOWING")
val whenExpression = syntheticCallGenerator.generateCalleeForWhenExpression(whenExpression) ?: run {
dataFlowAnalyzer.exitWhenExpression(whenExpression)
whenExpression.resultType = FirErrorTypeRefImpl(null, "")
return@with whenExpression.compose()
}
val expectedTypeRef = data as FirTypeRef?
val result = callCompleter.completeCall(whenExpression, expectedTypeRef)
dataFlowAnalyzer.exitWhenExpression(result)
result.compose()
}
}
private fun FirWhenExpression.isOneBranch(): Boolean {
if (branches.size == 1) return true
if (branches.size > 2) return false
val lastBranch = branches.last()
return lastBranch.condition is FirElseIfTrueCondition && lastBranch.result is FirEmptyExpressionBlock
}
override fun transformWhenBranch(whenBranch: FirWhenBranch, data: Any?): CompositeTransformResult<FirWhenBranch> {
return whenBranch.also { dataFlowAnalyzer.enterWhenBranchCondition(whenBranch) }
.transformCondition(this, data).also { dataFlowAnalyzer.exitWhenBranchCondition(it) }
.transformResult(this, data).also { dataFlowAnalyzer.exitWhenBranchResult(it) }
.compose()
}
override fun transformWhenSubjectExpression(
whenSubjectExpression: FirWhenSubjectExpression,
data: Any?
): CompositeTransformResult<FirStatement> {
val parentWhen = whenSubjectExpression.whenSubject.whenExpression
val subjectType = parentWhen.subject?.resultType ?: parentWhen.subjectVariable?.returnTypeRef
if (subjectType != null) {
whenSubjectExpression.resultType = subjectType
}
return whenSubjectExpression.compose()
}
override fun <T> transformConstExpression(constExpression: FirConstExpression<T>, data: Any?): CompositeTransformResult<FirStatement> {
val expectedType = data as FirTypeRef?
val kind = constExpression.kind
if (expectedType == null || expectedType is FirImplicitTypeRef ||
kind == IrConstKind.Null || kind == IrConstKind.Boolean || kind == IrConstKind.Char
) {
val symbol = when (kind) {
IrConstKind.Null -> StandardClassIds.Nothing(symbolProvider)
IrConstKind.Boolean -> StandardClassIds.Boolean(symbolProvider)
IrConstKind.Char -> StandardClassIds.Char(symbolProvider)
IrConstKind.Byte -> StandardClassIds.Byte(symbolProvider)
IrConstKind.Short -> StandardClassIds.Short(symbolProvider)
IrConstKind.Int -> StandardClassIds.Int(symbolProvider)
IrConstKind.Long -> StandardClassIds.Long(symbolProvider)
IrConstKind.String -> StandardClassIds.String(symbolProvider)
IrConstKind.Float -> StandardClassIds.Float(symbolProvider)
IrConstKind.Double -> StandardClassIds.Double(symbolProvider)
}
val type = ConeClassTypeImpl(symbol.toLookupTag(), emptyArray(), isNullable = kind == IrConstKind.Null)
constExpression.resultType = FirResolvedTypeRefImpl(null, type, emptyList())
} else {
constExpression.resultType = if (kind != IrConstKind.Null) {
expectedType.resolvedTypeFromPrototype(
expectedType.coneTypeUnsafe<ConeKotlinType>().withNullability(ConeNullability.NOT_NULL)
)
} else {
expectedType
}
}
return transformExpression(constExpression, data).also {
dataFlowAnalyzer.exitConstExpresion(it.single as FirConstExpression<*>)
}
}
override fun transformDeclaration(declaration: FirDeclaration, data: Any?): CompositeTransformResult<FirDeclaration> {
return withContainer(declaration) {
super.transformDeclaration(declaration, data)
}
}
override fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: Any?): CompositeTransformResult<FirStatement> {
dataFlowAnalyzer.enterAnnotationCall(annotationCall)
return (annotationCall.transformChildren(this, data) as FirAnnotationCall).also {
dataFlowAnalyzer.exitAnnotationCall(it)
}.compose()
}
override fun <F : FirFunction<F>> transformFunction(function: FirFunction<F>, data: Any?): CompositeTransformResult<FirDeclaration> {
return withScopeCleanup(localScopes) {
localScopes += FirLocalScope()
dataFlowAnalyzer.enterFunction(function)
transformDeclaration(function, data).also {
val result = it.single as FirFunction<*>
dataFlowAnalyzer.exitFunction(result)?.let { controlFlowGraph ->
result.transformControlFlowGraphReference(ControlFlowGraphReferenceTransformer, controlFlowGraph)
}
}
}
}
private fun transformFunctionWithGivenSignature(
function: FirFunction<*>,
returnTypeRef: FirTypeRef,
receiverTypeRef: FirTypeRef? = null
): CompositeTransformResult<FirDeclaration> {
if (function is FirNamedFunction) {
localScopes.lastOrNull()?.storeDeclaration(function)
}
val result = transformFunction(function, returnTypeRef).single as FirFunction<*>
val body = result.body
return if (result.returnTypeRef is FirImplicitTypeRef && body != null) {
result.transformReturnTypeRef(this, body.resultType)
result
} else {
result
}.compose()
}
override fun transformNamedFunction(namedFunction: FirNamedFunction, data: Any?): CompositeTransformResult<FirDeclaration> {
val returnTypeRef = namedFunction.returnTypeRef
if ((returnTypeRef !is FirImplicitTypeRef) && implicitTypeOnly) {
return namedFunction.compose()
}
return withFullBodyResolve {
if (returnTypeRef is FirImplicitTypeRef) {
namedFunction.transformReturnTypeRef(StoreType, FirComputingImplicitTypeRef)
}
val receiverTypeRef = namedFunction.receiverTypeRef
if (receiverTypeRef != null) {
withLabelAndReceiverType(namedFunction.name, namedFunction, receiverTypeRef.coneTypeUnsafe()) {
transformFunctionWithGivenSignature(namedFunction, returnTypeRef, receiverTypeRef)
}
} else {
transformFunctionWithGivenSignature(namedFunction, returnTypeRef)
}
}
}
override fun transformPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: Any?): CompositeTransformResult<FirDeclaration> {
if (propertyAccessor is FirDefaultPropertyAccessor || propertyAccessor.body == null) {
return transformFunction(propertyAccessor, data)
}
val returnTypeRef = propertyAccessor.returnTypeRef
if (returnTypeRef is FirImplicitTypeRef && data !is FirResolvedTypeRef) {
propertyAccessor.transformReturnTypeRef(StoreType, FirComputingImplicitTypeRef)
}
return if (data is FirResolvedTypeRef && returnTypeRef !is FirResolvedTypeRef) {
transformFunctionWithGivenSignature(propertyAccessor, data)
} else {
transformFunctionWithGivenSignature(propertyAccessor, returnTypeRef)
}
}
private fun storeVariableReturnType(variable: FirVariable<*>) {
val initializer = variable.initializer
if (variable.returnTypeRef is FirImplicitTypeRef) {
when {
initializer != null -> {
variable.transformReturnTypeRef(
this,
when (val resultType = initializer.resultType) {
is FirImplicitTypeRef -> FirErrorTypeRefImpl(
null,
"No result type for initializer"
)
else -> resultType
}
)
}
variable.getter != null && variable.getter !is FirDefaultPropertyAccessor -> {
variable.transformReturnTypeRef(
this,
when (val resultType = variable.getter?.returnTypeRef) {
is FirImplicitTypeRef -> FirErrorTypeRefImpl(
null,
"No result type for getter"
)
else -> resultType
}
)
}
else -> {
variable.transformReturnTypeRef(
this, FirErrorTypeRefImpl(null, "Cannot infer variable type without initializer / getter / delegate")
)
}
}
if (variable.getter?.returnTypeRef is FirImplicitTypeRef) {
variable.getter?.transformReturnTypeRef(this, variable.returnTypeRef)
}
}
}
private fun <F : FirVariable<F>> FirVariable<F>.transformAccessors() {
var enhancedTypeRef = returnTypeRef
getter?.transform<FirDeclaration, Any?>(this@FirBodyResolveTransformer, enhancedTypeRef)
if (returnTypeRef is FirImplicitTypeRef) {
storeVariableReturnType(this)
enhancedTypeRef = returnTypeRef
}
setter?.let {
it.valueParameters[0].transformReturnTypeRef(StoreType, enhancedTypeRef)
it.transform<FirDeclaration, Any?>(this@FirBodyResolveTransformer, enhancedTypeRef)
}
}
override fun transformWrappedDelegateExpression(
wrappedDelegateExpression: FirWrappedDelegateExpression,
data: Any?
): CompositeTransformResult<FirStatement> {
transformExpression(wrappedDelegateExpression, data)
with(wrappedDelegateExpression) {
val delegateProviderTypeRef = delegateProvider.typeRef
val useDelegateProvider = delegateProviderTypeRef is FirResolvedTypeRef &&
delegateProviderTypeRef !is FirErrorTypeRef &&
delegateProviderTypeRef.type !is ConeKotlinErrorType
return if (useDelegateProvider) delegateProvider.compose() else expression.compose()
}
}
override fun <F : FirVariable<F>> transformVariable(variable: FirVariable<F>, data: Any?): CompositeTransformResult<FirDeclaration> {
variable.transformChildrenWithoutAccessors(this, variable.returnTypeRef)
if (variable.initializer != null) {
storeVariableReturnType(variable)
}
variable.transformAccessors()
if (variable !is FirProperty) {
localScopes.lastOrNull()?.storeDeclaration(variable)
}
variable.resolvePhase = transformerPhase
dataFlowAnalyzer.exitVariableDeclaration(variable)
return variable.compose()
}
override fun transformProperty(property: FirProperty, data: Any?): CompositeTransformResult<FirDeclaration> {
val returnTypeRef = property.returnTypeRef
if (returnTypeRef !is FirImplicitTypeRef && implicitTypeOnly) return property.compose()
if (property.resolvePhase == transformerPhase) return property.compose()
dataFlowAnalyzer.enterProperty(property)
if (returnTypeRef is FirImplicitTypeRef) {
property.transformReturnTypeRef(StoreType, FirComputingImplicitTypeRef)
}
return withFullBodyResolve {
withScopeCleanup(localScopes) {
localScopes.addIfNotNull(primaryConstructorParametersScope)
withContainer(property) {
property.transformChildrenWithoutAccessors(this, returnTypeRef)
if (property.initializer != null) {
storeVariableReturnType(property)
}
withScopeCleanup(localScopes) {
localScopes.add(FirLocalScope().apply {
storeBackingField(property)
})
property.transformAccessors()
}
}
property.resolvePhase = transformerPhase
val controlFlowGraph = dataFlowAnalyzer.exitProperty(property)
property.transformControlFlowGraphReference(ControlFlowGraphReferenceTransformer, controlFlowGraph)
property.compose()
}
}
}
override fun transformExpression(expression: FirExpression, data: Any?): CompositeTransformResult<FirStatement> {
if (expression.resultType is FirImplicitTypeRef && expression !is FirWrappedExpression) {
val type = FirErrorTypeRefImpl(expression.psi, "Type calculating for ${expression::class} is not supported")
expression.resultType = type
}
return (expression.transformChildren(this, data) as FirStatement).compose()
}
override fun transformGetClassCall(getClassCall: FirGetClassCall, data: Any?): CompositeTransformResult<FirStatement> {
val transformedGetClassCall = transformExpression(getClassCall, data).single as FirGetClassCall
val kClassSymbol = ClassId.fromString("kotlin/reflect/KClass")(session.service())
val typeOfExpression = when (val lhs = transformedGetClassCall.argument) {
is FirResolvedQualifier -> {
val classId = lhs.classId
if (classId != null) {
val symbol = symbolProvider.getClassLikeSymbolByFqName(classId)!!
// TODO: Unify logic?
symbol.constructType(
Array(symbol.phasedFir.typeParameters.size) {
ConeStarProjection
},
isNullable = false
)
} else {
lhs.resultType.coneTypeUnsafe<ConeKotlinType>()
}
}
else -> lhs.resultType.coneTypeUnsafe<ConeKotlinType>()
}
transformedGetClassCall.resultType =
FirResolvedTypeRefImpl(
null,
kClassSymbol.constructType(arrayOf(typeOfExpression), false),
emptyList()
)
return transformedGetClassCall.compose()
}
override fun transformBinaryLogicExpression(
binaryLogicExpression: FirBinaryLogicExpression,
data: Any?
): CompositeTransformResult<FirStatement> {
val booleanType = builtinTypes.booleanType
return when (binaryLogicExpression.kind) {
FirBinaryLogicExpression.OperationKind.AND ->
binaryLogicExpression.also(dataFlowAnalyzer::enterBinaryAnd)
.transformLeftOperand(this, booleanType).also(dataFlowAnalyzer::exitLeftBinaryAndArgument)
.transformRightOperand(this, booleanType).also(dataFlowAnalyzer::exitBinaryAnd)
FirBinaryLogicExpression.OperationKind.OR ->
binaryLogicExpression.also(dataFlowAnalyzer::enterBinaryOr)
.transformLeftOperand(this, booleanType).also(dataFlowAnalyzer::exitLeftBinaryOrArgument)
.transformRightOperand(this, booleanType).also(dataFlowAnalyzer::exitBinaryOr)
}.transformRestChildren(this, booleanType).also {
it.resultType = booleanType
}.compose()
}
override fun transformOperatorCall(operatorCall: FirOperatorCall, data: Any?): CompositeTransformResult<FirStatement> {
val result = if (operatorCall.operation in FirOperation.BOOLEANS) {
(operatorCall.transformChildren(this, noExpectedType) as FirOperatorCall).also {
it.resultType = builtinTypes.booleanType
}
} else {
transformExpression(operatorCall, data).single
} as FirOperatorCall
dataFlowAnalyzer.exitOperatorCall(result)
return result.compose()
}
override fun transformWhileLoop(whileLoop: FirWhileLoop, data: Any?): CompositeTransformResult<FirStatement> {
return whileLoop.also(dataFlowAnalyzer::enterWhileLoop)
.transformCondition(this, data).also(dataFlowAnalyzer::exitWhileLoopCondition)
.transformBlock(this, data).also(dataFlowAnalyzer::exitWhileLoop)
.transformRestChildren(this, data).compose()
}
override fun transformDoWhileLoop(doWhileLoop: FirDoWhileLoop, data: Any?): CompositeTransformResult<FirStatement> {
return doWhileLoop.also(dataFlowAnalyzer::enterDoWhileLoop)
.transformBlock(this, data).also(dataFlowAnalyzer::enterDoWhileLoopCondition)
.transformCondition(this, data).also(dataFlowAnalyzer::exitDoWhileLoop)
.transformRestChildren(this, data).compose()
}
// ----------------------- Util functions -----------------------
private inline fun <T> withLabelAndReceiverType(
labelName: Name,
owner: FirDeclaration,
type: ConeKotlinType,
block: () -> T
): T {
val implicitReceiverValue = when (owner) {
is FirRegularClass -> {
ImplicitDispatchReceiverValue(owner.symbol, type, symbolProvider, session, scopeSession)
}
is FirFunction<*> -> {
ImplicitExtensionReceiverValue(owner.symbol, type, session, scopeSession)
}
else -> {
throw IllegalArgumentException("Incorrect label & receiver owner: ${owner.javaClass}")
}
}
implicitReceiverStack.add(labelName, implicitReceiverValue)
val result = block()
implicitReceiverStack.pop(labelName)
return result
}
protected inline fun <T> withScopeCleanup(scopes: MutableList<*>, crossinline l: () -> T): T {
val sizeBefore = scopes.size
return try {
l()
} finally {
val size = scopes.size
assert(size >= sizeBefore)
repeat(size - sizeBefore) {
scopes.let { it.removeAt(it.size - 1) }
}
}
}
private inline fun <T> withFullBodyResolve(crossinline l: () -> T): T {
if (!implicitTypeOnly) return l()
implicitTypeOnly = false
return try {
l()
} finally {
implicitTypeOnly = true
}
}
internal fun <T> storeTypeFromCallee(access: T) where T : FirQualifiedAccess, T : FirExpression {
access.resultType = callCompleter.typeFromCallee(access)
}
private fun <T> withContainer(declaration: FirDeclaration, f: () -> T): T {
val prevContainer = _container
_container = declaration
val result = f()
_container = prevContainer
return result
}
fun <D> FirElement.visitNoTransform(transformer: FirTransformer<D>, data: D) {
val result = this.transform<FirElement, D>(transformer, data)
require(result.single === this) { "become ${result.single}: `${result.single.render()}`, was ${this}: `${this.render()}`" }
}
}
private fun inferenceComponents(session: FirSession, returnTypeCalculator: ReturnTypeCalculator, scopeSession: ScopeSession) =
InferenceComponents(object : ConeInferenceContext, TypeSystemInferenceExtensionContextDelegate, DataFlowInferenceContext {
override fun findCommonIntegerLiteralTypesSuperType(explicitSupertypes: List<SimpleTypeMarker>): SimpleTypeMarker? {
// TODO: implement
return null
}
override fun TypeConstructorMarker.getApproximatedIntegerLiteralType(): KotlinTypeMarker {
TODO("not implemented")
}
override val session: FirSession
get() = session
override fun KotlinTypeMarker.removeExactAnnotation(): KotlinTypeMarker {
return this
}
override fun TypeConstructorMarker.toErrorType(): SimpleTypeMarker {
require(this is ErrorTypeConstructor)
return ConeClassErrorType(reason)
}
}, session, returnTypeCalculator, scopeSession)
class FirDesignatedBodyResolveTransformer(
private val designation: Iterator<FirElement>,
session: FirSession,
scopeSession: ScopeSession = ScopeSession(),
implicitTypeOnly: Boolean = true
) : FirBodyResolveTransformer(
session,
phase = FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE,
implicitTypeOnly = implicitTypeOnly,
scopeSession = scopeSession
) {
override fun <E : FirElement> transformElement(element: E, data: Any?): CompositeTransformResult<E> {
if (designation.hasNext()) {
designation.next().visitNoTransform(this, data)
return element.compose()
}
return super.transformElement(element, data)
}
}
@Deprecated("It is temp", level = DeprecationLevel.WARNING, replaceWith = ReplaceWith("TODO(\"что-то нормальное\")"))
class FirImplicitTypeBodyResolveTransformerAdapter : FirTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
return element.compose()
}
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
val transformer = FirBodyResolveTransformer(file.fileSession, phase = FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, implicitTypeOnly = true)
return file.transform(transformer, null)
}
}
@Deprecated("It is temp", level = DeprecationLevel.WARNING, replaceWith = ReplaceWith("TODO(\"что-то нормальное\")"))
class FirBodyResolveTransformerAdapter : FirTransformer<Nothing?>() {
override fun <E : FirElement> transformElement(element: E, data: Nothing?): CompositeTransformResult<E> {
return element.compose()
}
override fun transformFile(file: FirFile, data: Nothing?): CompositeTransformResult<FirFile> {
// Despite of real phase is EXPRESSIONS, we state IMPLICIT_TYPES here, because DECLARATIONS previous phase is OK for us
val transformer = FirBodyResolveTransformer(file.fileSession, phase = FirResolvePhase.IMPLICIT_TYPES_BODY_RESOLVE, implicitTypeOnly = false)
return file.transform(transformer, null)
}
}
inline fun <reified T : FirElement> FirBasedSymbol<*>.firUnsafe(): T {
val fir = this.fir
require(fir is T) {
"Not an expected fir element type = ${T::class}, symbol = ${this}, fir = ${fir.renderWithType()}"
}
return fir
}
internal inline var FirExpression.resultType: FirTypeRef
get() = typeRef
set(type) {
replaceTypeRef(type)
}
| 7 | null | 1 | 1 | f17e9ba9febdabcf7a5e0f17e4be02e0f9e87f13 | 49,099 | kotlin | Apache License 2.0 |
bindings/core/gio/src/nativeMain/kotlin/org/gtkkn/bindings/gio/DBusMessageByteOrder.kt | gtk-kn | 609,191,895 | false | {"Kotlin": 10448515, "Shell": 2740} | // This is a generated file. Do not modify.
package org.gtkkn.bindings.gio
import org.gtkkn.native.gio.GDBusMessageByteOrder
import org.gtkkn.native.gio.GDBusMessageByteOrder.G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN
import org.gtkkn.native.gio.GDBusMessageByteOrder.G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN
/**
* Enumeration used to describe the byte order of a D-Bus message.
* @since 2.26
*/
public enum class DBusMessageByteOrder(
public val nativeValue: GDBusMessageByteOrder,
) {
/**
* The byte order is big endian.
*/
BIG_ENDIAN(G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN),
/**
* The byte order is little endian.
*/
LITTLE_ENDIAN(G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN),
;
public companion object {
public fun fromNativeValue(nativeValue: GDBusMessageByteOrder): DBusMessageByteOrder =
when (nativeValue) {
G_DBUS_MESSAGE_BYTE_ORDER_BIG_ENDIAN -> BIG_ENDIAN
G_DBUS_MESSAGE_BYTE_ORDER_LITTLE_ENDIAN -> LITTLE_ENDIAN
else -> error("invalid nativeValue")
}
}
}
| 0 | Kotlin | 0 | 13 | c033c245f1501134c5b9b46212cd153c61f7efea | 1,093 | gtk-kn | Creative Commons Attribution 4.0 International |
kamp-core/src/main/kotlin/ch/leadrian/samp/kamp/core/runtime/command/PickupCommandParameterResolver.kt | Double-O-Seven | 142,487,686 | false | {"Kotlin": 3854710, "C": 23964, "C++": 23699, "Java": 4753, "Dockerfile": 769, "Objective-C": 328, "Batchfile": 189} | package ch.leadrian.samp.kamp.core.runtime.command
import ch.leadrian.samp.kamp.core.api.entity.Pickup
import ch.leadrian.samp.kamp.core.api.entity.id.PickupId
import ch.leadrian.samp.kamp.core.runtime.entity.registry.PickupRegistry
import javax.inject.Inject
internal class PickupCommandParameterResolver
@Inject
constructor(pickupRegistry: PickupRegistry) : EntityCommandParameterResolver<Pickup, PickupId>(pickupRegistry) {
override val parameterType: Class<Pickup> = Pickup::class.java
} | 1 | Kotlin | 1 | 7 | af07b6048210ed6990e8b430b3a091dc6f64c6d9 | 499 | kamp | Apache License 2.0 |
compiler/daemon/src/org/jetbrains/kotlin/daemon/CompileServiceImpl.kt | JakeWharton | 99,388,807 | false | null | /*
* Copyright 2010-2015 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.daemon
import com.intellij.openapi.vfs.impl.ZipHandler
import org.jetbrains.kotlin.cli.common.CLICompiler
import org.jetbrains.kotlin.cli.common.ExitCode
import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
import org.jetbrains.kotlin.config.Services
import org.jetbrains.kotlin.daemon.common.*
import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
import org.jetbrains.kotlin.progress.CompilationCanceledStatus
import org.jetbrains.kotlin.utils.addToStdlib.check
import java.io.BufferedOutputStream
import java.io.File
import java.io.PrintStream
import java.rmi.NoSuchObjectException
import java.rmi.registry.Registry
import java.rmi.server.UnicastRemoteObject
import java.util.*
import java.util.concurrent.TimeUnit
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.locks.ReentrantReadWriteLock
import java.util.logging.Level
import java.util.logging.Logger
import kotlin.concurrent.read
import kotlin.concurrent.schedule
import kotlin.concurrent.write
fun nowSeconds() = TimeUnit.NANOSECONDS.toSeconds(System.nanoTime())
interface CompilerSelector {
operator fun get(targetPlatform: CompileService.TargetPlatform): CLICompiler<*>
}
interface EventManger {
fun onCompilationFinished(f : () -> Unit)
}
private class EventMangerImpl : EventManger {
private val onCompilationFinished = arrayListOf<() -> Unit>()
override fun onCompilationFinished(f: () -> Unit) {
onCompilationFinished.add(f)
}
fun fireCompilationFinished() {
onCompilationFinished.forEach { it() }
}
}
class CompileServiceImpl(
val registry: Registry,
val compiler: CompilerSelector,
val compilerId: CompilerId,
val daemonOptions: DaemonOptions,
val daemonJVMOptions: DaemonJVMOptions,
val port: Int,
val timer: Timer,
val onShutdown: () -> Unit
) : CompileService {
// wrapped in a class to encapsulate alive check logic
private class ClientOrSessionProxy(val aliveFlagPath: String?) {
val registered = nowSeconds()
val secondsSinceRegistered: Long get() = nowSeconds() - registered
val isAlive: Boolean get() = aliveFlagPath?.let { File(it).exists() } ?: true // assuming that if no file was given, the client is alive
}
private val sessionsIdCounter = AtomicInteger(0)
private val compilationsCounter = AtomicInteger(0)
private val internalRng = Random()
private val classpathWatcher = LazyClasspathWatcher(compilerId.compilerClasspath)
enum class Aliveness {
// !!! ordering of values is used in state comparison
Dying, LastSession, Alive
}
// TODO: encapsulate operations on state here
private val state = object {
val clientProxies: MutableSet<ClientOrSessionProxy> = hashSetOf()
val sessions: MutableMap<Int, ClientOrSessionProxy> = hashMapOf()
val delayedShutdownQueued = AtomicBoolean(false)
var alive = AtomicInteger(Aliveness.Alive.ordinal)
}
@Volatile private var _lastUsedSeconds = nowSeconds()
val lastUsedSeconds: Long get() = if (rwlock.isWriteLocked || rwlock.readLockCount - rwlock.readHoldCount > 0) nowSeconds() else _lastUsedSeconds
private val log by lazy { Logger.getLogger("compiler") }
private val rwlock = ReentrantReadWriteLock()
private var runFile: File
init {
val runFileDir = File(daemonOptions.runFilesPathOrDefault)
runFileDir.mkdirs()
runFile = File(runFileDir,
makeRunFilenameString(timestamp = "%tFT%<tH-%<tM-%<tS.%<tLZ".format(Calendar.getInstance(TimeZone.getTimeZone("Z"))),
digest = compilerId.compilerClasspath.map { File(it).absolutePath }.distinctStringsDigest().toHexString(),
port = port.toString()))
try {
if (!runFile.createNewFile()) throw Exception("createNewFile returned false")
} catch (e: Exception) {
throw IllegalStateException("Unable to create run file '${runFile.absolutePath}'", e)
}
runFile.deleteOnExit()
}
// RMI-exposed API
override fun getDaemonOptions(): CompileService.CallResult<DaemonOptions> = ifAlive { daemonOptions }
override fun getDaemonJVMOptions(): CompileService.CallResult<DaemonJVMOptions> = ifAlive { daemonJVMOptions }
override fun registerClient(aliveFlagPath: String?): CompileService.CallResult<Nothing> = ifAlive_Nothing {
synchronized(state.clientProxies) {
state.clientProxies.add(ClientOrSessionProxy(aliveFlagPath))
}
}
override fun getClients(): CompileService.CallResult<List<String>> = ifAlive {
synchronized(state.clientProxies) {
state.clientProxies.mapNotNull { it.aliveFlagPath }
}
}
// TODO: consider tying a session to a client and use this info to cleanup
override fun leaseCompileSession(aliveFlagPath: String?): CompileService.CallResult<Int> = ifAlive(minAliveness = Aliveness.Alive) {
// fighting hypothetical integer wrapping
var newId = sessionsIdCounter.incrementAndGet()
val session = ClientOrSessionProxy(aliveFlagPath)
for (attempt in 1..100) {
if (newId != CompileService.NO_SESSION) {
synchronized(state.sessions) {
if (!state.sessions.containsKey(newId)) {
state.sessions.put(newId, session)
log.info("leased a new session $newId, client alive file: $aliveFlagPath")
return@ifAlive newId
}
}
}
// assuming wrap, jumping to random number to reduce probability of further clashes
newId = sessionsIdCounter.addAndGet(internalRng.nextInt())
}
throw IllegalStateException("Invalid state or algorithm error")
}
override fun releaseCompileSession(sessionId: Int) = ifAlive_Nothing(minAliveness = Aliveness.LastSession) {
synchronized(state.sessions) {
state.sessions.remove(sessionId)
log.info("cleaning after session $sessionId")
clearJarCache()
if (state.sessions.isEmpty()) {
// TODO: and some goes here
}
}
timer.schedule(0) {
periodicAndAfterSessionCheck()
}
}
override fun checkCompilerId(expectedCompilerId: CompilerId): Boolean =
(compilerId.compilerVersion.isEmpty() || compilerId.compilerVersion == expectedCompilerId.compilerVersion) &&
(compilerId.compilerClasspath.all { expectedCompilerId.compilerClasspath.contains(it) }) &&
!classpathWatcher.isChanged
override fun getUsedMemory(): CompileService.CallResult<Long> = ifAlive { usedMemory(withGC = true) }
override fun shutdown(): CompileService.CallResult<Nothing> = ifAliveExclusive_Nothing(minAliveness = Aliveness.LastSession, ignoreCompilerChanged = true) {
shutdownImpl()
}
override fun scheduleShutdown(graceful: Boolean): CompileService.CallResult<Boolean> = ifAlive(minAliveness = Aliveness.Alive) {
if (!graceful || state.alive.compareAndSet(Aliveness.Alive.ordinal, Aliveness.LastSession.ordinal)) {
timer.schedule(0) {
ifAliveExclusive(minAliveness = Aliveness.LastSession, ignoreCompilerChanged = true) {
if (!graceful || state.sessions.isEmpty()) {
shutdownImpl()
}
else {
log.info("Some sessions are active, waiting for them to finish")
}
}
}
true
}
else false
}
override fun remoteCompile(sessionId: Int,
targetPlatform: CompileService.TargetPlatform,
args: Array<out String>,
servicesFacade: CompilerCallbackServicesFacade,
compilerOutputStream: RemoteOutputStream,
outputFormat: CompileService.OutputFormat,
serviceOutputStream: RemoteOutputStream,
operationsTracer: RemoteOperationsTracer?
): CompileService.CallResult<Int> =
doCompile(sessionId, args, compilerOutputStream, serviceOutputStream, operationsTracer) { printStream, eventManager, profiler ->
when (outputFormat) {
CompileService.OutputFormat.PLAIN -> compiler[targetPlatform].exec(printStream, *args)
CompileService.OutputFormat.XML -> compiler[targetPlatform].execAndOutputXml(printStream, createCompileServices(servicesFacade, eventManager, profiler), *args)
}
}
override fun remoteIncrementalCompile(sessionId: Int,
targetPlatform: CompileService.TargetPlatform,
args: Array<out String>,
servicesFacade: CompilerCallbackServicesFacade,
compilerOutputStream: RemoteOutputStream,
compilerOutputFormat: CompileService.OutputFormat,
serviceOutputStream: RemoteOutputStream,
operationsTracer: RemoteOperationsTracer?
): CompileService.CallResult<Int> =
doCompile(sessionId, args, compilerOutputStream, serviceOutputStream, operationsTracer) { printStream, eventManager, profiler ->
when (compilerOutputFormat) {
CompileService.OutputFormat.PLAIN -> throw NotImplementedError("Only XML output is supported in remote incremental compilation")
CompileService.OutputFormat.XML -> compiler[targetPlatform].execAndOutputXml(printStream, createCompileServices(servicesFacade, eventManager, profiler), *args)
}
}
// internal implementation stuff
// TODO: consider matching compilerId coming from outside with actual one
// private val selfCompilerId by lazy {
// CompilerId(
// compilerClasspath = System.getProperty("java.class.path")
// ?.split(File.pathSeparator)
// ?.map { File(it) }
// ?.filter { it.exists() }
// ?.map { it.absolutePath }
// ?: listOf(),
// compilerVersion = loadKotlinVersionFromResource()
// )
// }
init {
// assuming logically synchronized
try {
// cleanup for the case of incorrect restart and many other situations
UnicastRemoteObject.unexportObject(this, false)
}
catch (e: NoSuchObjectException) {
// ignoring if object already exported
}
val stub = UnicastRemoteObject.exportObject(this, port, LoopbackNetworkInterface.clientLoopbackSocketFactory, LoopbackNetworkInterface.serverLoopbackSocketFactory) as CompileService
registry.rebind (COMPILER_SERVICE_RMI_NAME, stub);
timer.schedule(0) {
initiateElections()
}
timer.schedule(delay = DAEMON_PERIODIC_CHECK_INTERVAL_MS, period = DAEMON_PERIODIC_CHECK_INTERVAL_MS) {
try {
periodicAndAfterSessionCheck()
}
catch (e: Exception) {
System.err.println("Exception in timer thread: " + e.message)
e.printStackTrace(System.err)
log.log(Level.SEVERE, "Exception in timer thread", e)
}
}
}
private fun periodicAndAfterSessionCheck() {
ifAlive_Nothing(minAliveness = Aliveness.LastSession) {
// 1. check if unused for a timeout - shutdown
if (shutdownCondition({ daemonOptions.autoshutdownUnusedSeconds != COMPILE_DAEMON_TIMEOUT_INFINITE_S && compilationsCounter.get() == 0 && nowSeconds() - lastUsedSeconds > daemonOptions.autoshutdownUnusedSeconds },
"Unused timeout exceeded ${daemonOptions.autoshutdownUnusedSeconds}s, shutting down")) {
shutdown()
}
else {
synchronized(state.sessions) {
// 2. check if any session hanged - clean
// making copy of the list before calling release
state.sessions.filterValues { !it.isAlive }.keys.toArrayList()
}.forEach { releaseCompileSession(it) }
// 3. check if in graceful shutdown state and all sessions are closed
if (shutdownCondition({ state.alive.get() == Aliveness.LastSession.ordinal && state.sessions.none()}, "All sessions finished, shutting down")) {
shutdown()
}
// 4. clean dead clients, then check if any left - conditional shutdown (with small delay)
synchronized(state.clientProxies) { state.clientProxies.removeAll(state.clientProxies.filter { !it.isAlive }) }
if (state.clientProxies.isEmpty() && compilationsCounter.get() > 0 && !state.delayedShutdownQueued.get()) {
log.info("No more clients left, delayed shutdown in ${daemonOptions.shutdownDelayMilliseconds}ms")
shutdownWithDelay()
}
// 5. check idle timeout - shutdown
if (shutdownCondition({ daemonOptions.autoshutdownIdleSeconds != COMPILE_DAEMON_TIMEOUT_INFINITE_S && nowSeconds() - lastUsedSeconds > daemonOptions.autoshutdownIdleSeconds },
"Idle timeout exceeded ${daemonOptions.autoshutdownIdleSeconds}s, shutting down") ||
// 6. discovery file removed - shutdown
shutdownCondition({ !runFile.exists() }, "Run file removed, shutting down") ||
// 7. compiler changed (seldom check) - shutdown
// TODO: could be too expensive anyway, consider removing this check
shutdownCondition({ classpathWatcher.isChanged }, "Compiler changed")) {
shutdown()
}
}
}
}
private fun initiateElections() {
ifAlive_Nothing {
val aliveWithOpts = walkDaemons(File(daemonOptions.runFilesPathOrDefault), compilerId, filter = { f, p -> p != port }, report = { lvl, msg -> log.info(msg) })
.map { Pair(it, it.getDaemonJVMOptions()) }
.filter { it.second.isGood }
.sortedWith(compareBy(DaemonJVMOptionsMemoryComparator().reversed(), { it.second.get() }))
if (aliveWithOpts.any()) {
val fattestOpts = aliveWithOpts.first().second.get()
// second part of the condition means that we prefer other daemon if is "equal" to the current one
if (fattestOpts memorywiseFitsInto daemonJVMOptions && !(daemonJVMOptions memorywiseFitsInto fattestOpts)) {
// all others are smaller that me, take overs' clients and shut them down
aliveWithOpts.forEach {
it.first.getClients().check { it.isGood }?.let {
it.get().forEach { registerClient(it) }
}
it.first.scheduleShutdown(true)
}
}
else if (daemonJVMOptions memorywiseFitsInto fattestOpts) {
// there is at least one bigger, handover my clients to it and shutdown
scheduleShutdown(true)
aliveWithOpts.first().first.let { fattest ->
getClients().check { it.isGood }?.let {
it.get().forEach { fattest.registerClient(it) }
}
}
}
// else - do nothing, all daemons are staying
// TODO: implement some behaviour here, e.g.:
// - shutdown/takeover smaller daemon
// - run (or better persuade client to run) a bigger daemon (in fact may be even simple shutdown will do, because of client's daemon choosing logic)
}
}
}
private fun shutdownImpl() {
log.info("Shutdown started")
state.alive.set(Aliveness.Dying.ordinal)
UnicastRemoteObject.unexportObject(this, true)
log.info("Shutdown complete")
onShutdown()
}
private fun shutdownWithDelay() {
state.delayedShutdownQueued.set(true)
val currentCompilationsCount = compilationsCounter.get()
timer.schedule(daemonOptions.shutdownDelayMilliseconds) {
state.delayedShutdownQueued.set(false)
if (currentCompilationsCount == compilationsCounter.get()) {
log.fine("Execute delayed shutdown")
shutdown()
}
else {
log.info("Cancel delayed shutdown due to new client")
}
}
}
private inline fun shutdownCondition(check: () -> Boolean, message: String): Boolean {
val res = check()
if (res) {
log.info(message)
}
return res
}
private fun doCompile(sessionId: Int,
args: Array<out String>,
compilerMessagesStreamProxy: RemoteOutputStream,
serviceOutputStreamProxy: RemoteOutputStream,
operationsTracer: RemoteOperationsTracer?,
body: (PrintStream, EventManger, Profiler) -> ExitCode): CompileService.CallResult<Int> =
ifAlive {
operationsTracer?.before("compile")
compilationsCounter.incrementAndGet()
val rpcProfiler = if (daemonOptions.reportPerf) WallAndThreadTotalProfiler() else DummyProfiler()
val eventManger = EventMangerImpl()
val compilerMessagesStream = PrintStream(BufferedOutputStream(RemoteOutputStreamClient(compilerMessagesStreamProxy, rpcProfiler), 4096))
val serviceOutputStream = PrintStream(BufferedOutputStream(RemoteOutputStreamClient(serviceOutputStreamProxy, rpcProfiler), 4096))
try {
checkedCompile(args, serviceOutputStream, rpcProfiler) {
val res = body(compilerMessagesStream, eventManger, rpcProfiler).code
_lastUsedSeconds = nowSeconds()
res
}
}
finally {
serviceOutputStream.flush()
compilerMessagesStream.flush()
eventManger.fireCompilationFinished()
operationsTracer?.after("compile")
}
}
private fun createCompileServices(facade: CompilerCallbackServicesFacade, eventManger: EventManger, rpcProfiler: Profiler): Services {
val builder = Services.Builder()
if (facade.hasIncrementalCaches() || facade.hasLookupTracker()) {
builder.register(IncrementalCompilationComponents::class.java, RemoteIncrementalCompilationComponentsClient(facade, eventManger, rpcProfiler))
}
if (facade.hasCompilationCanceledStatus()) {
builder.register(CompilationCanceledStatus::class.java, RemoteCompilationCanceledStatusClient(facade, rpcProfiler))
}
return builder.build()
}
private fun<R> checkedCompile(args: Array<out String>, serviceOut: PrintStream, rpcProfiler: Profiler, body: () -> R): R {
try {
if (args.none())
throw IllegalArgumentException("Error: empty arguments list.")
log.info("Starting compilation with args: " + args.joinToString(" "))
val profiler = if (daemonOptions.reportPerf) WallAndThreadAndMemoryTotalProfiler(withGC = false) else DummyProfiler()
val res = profiler.withMeasure(null, body)
val endMem = if (daemonOptions.reportPerf) usedMemory(withGC = false) else 0L
log.info("Done with result " + res.toString())
if (daemonOptions.reportPerf) {
fun Long.ms() = TimeUnit.NANOSECONDS.toMillis(this)
fun Long.kb() = this / 1024
val pc = profiler.getTotalCounters()
val rpc = rpcProfiler.getTotalCounters()
"PERF: Compile on daemon: ${pc.time.ms()} ms; thread: user ${pc.threadUserTime.ms()} ms, sys ${(pc.threadTime - pc.threadUserTime).ms()} ms; rpc: ${rpc.count} calls, ${rpc.time.ms()} ms, thread ${rpc.threadTime.ms()} ms; memory: ${endMem.kb()} kb (${"%+d".format(pc.memory.kb())} kb)".let {
serviceOut.println(it)
log.info(it)
}
// this will only be reported if if appropriate (e.g. ByClass) profiler is used
for ((obj, counters) in rpcProfiler.getCounters()) {
"PERF: rpc by $obj: ${counters.count} calls, ${counters.time.ms()} ms, thread ${counters.threadTime.ms()} ms".let {
serviceOut.println(it)
log.info(it)
}
}
}
return res
}
// TODO: consider possibilities to handle OutOfMemory
catch (e: Exception) {
log.info("Error: $e")
throw e
}
}
private fun clearJarCache() {
ZipHandler.clearFileAccessorCache()
val classloader = javaClass.classLoader
// TODO: replace the following code with direct call to CoreJarFileSystem.<clearCache> as soon as it will be available (hopefully in 15.02)
try {
KotlinCoreEnvironment.applicationEnvironment?.jarFileSystem.let { jarfs ->
val jarfsClass = classloader.loadClass("com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem")
val privateHandlersField = jarfsClass.getDeclaredField("myHandlers")
privateHandlersField.isAccessible = true
privateHandlersField.get(jarfs)?.let {
val clearMethod = privateHandlersField.type.getMethod("clear")
if (clearMethod != null) {
clearMethod.invoke(it)
log.info("successfully cleared com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem.myHandlers")
}
else {
log.info("unable to access com.intellij.openapi.vfs.impl.jar.CoreJarFileSystem.myHandlers.clear")
}
} ?: log.info("unable to access CoreJarFileSystem.myHandlers (${privateHandlersField.get(jarfs)})")
}
}
catch (e: Exception) {
log.log(Level.SEVERE, "error clearing CoreJarFileSystem", e)
}
}
// copied (with edit) from gradle plugin
private fun callVoidStaticMethod(classFqName: String, methodName: String) {
// compiler classloader == current classloader for now
// TODO: consider abstracting classloader, for easier changing it for a compiler
val cls = this.javaClass.classLoader.loadClass(classFqName)
val method = cls.getMethod(methodName)
method.invoke(null)
}
private fun<R> ifAlive(minAliveness: Aliveness = Aliveness.Alive, ignoreCompilerChanged: Boolean = false, body: () -> R): CompileService.CallResult<R> = rwlock.read {
ifAliveChecksImpl(minAliveness, ignoreCompilerChanged) { CompileService.CallResult.Good(body()) }
}
// TODO: find how to implement it without using unique name for this variant; making name deliberately ugly meanwhile
private fun ifAlive_Nothing(minAliveness: Aliveness = Aliveness.Alive, ignoreCompilerChanged: Boolean = false, body: () -> Unit): CompileService.CallResult<Nothing> = rwlock.read {
ifAliveChecksImpl(minAliveness, ignoreCompilerChanged) {
body()
CompileService.CallResult.Ok()
}
}
private fun<R> ifAliveExclusive(minAliveness: Aliveness = Aliveness.Alive, ignoreCompilerChanged: Boolean = false, body: () -> R): CompileService.CallResult<R> = rwlock.write {
ifAliveChecksImpl(minAliveness, ignoreCompilerChanged) { CompileService.CallResult.Good(body()) }
}
// see comment to ifAliveNothing
private fun<R> ifAliveExclusive_Nothing(minAliveness: Aliveness = Aliveness.Alive, ignoreCompilerChanged: Boolean = false, body: () -> Unit): CompileService.CallResult<R> = rwlock.write {
ifAliveChecksImpl(minAliveness, ignoreCompilerChanged) {
body()
CompileService.CallResult.Ok()
}
}
inline private fun<R> ifAliveChecksImpl(minAliveness: Aliveness = Aliveness.Alive, ignoreCompilerChanged: Boolean = false, body: () -> CompileService.CallResult<R>): CompileService.CallResult<R> =
when {
state.alive.get() < minAliveness.ordinal -> CompileService.CallResult.Dying()
!ignoreCompilerChanged && classpathWatcher.isChanged -> {
log.info("Compiler changed, scheduling shutdown")
timer.schedule(0) { shutdown() }
CompileService.CallResult.Dying()
}
else -> {
try {
body()
}
catch (e: Exception) {
log.log(Level.SEVERE, "Exception", e)
CompileService.CallResult.Error(e.message ?: "unknown")
}
}
}
}
| 7 | null | 5771 | 83 | 4383335168338df9bbbe2a63cb213a68d0858104 | 26,680 | kotlin | Apache License 2.0 |
koma-core-api/common/src/koma/internal/default/generated/ndarray/DefaultFloatNDArrayFactory.kt | drmoose | 117,384,470 | true | {"Kotlin": 644993, "Shell": 623} | /**
* THIS FILE IS AUTOGENERATED, DO NOT MODIFY. EDIT THE FILES IN templates/
* AND RUN ./gradlew :codegen INSTEAD!
*/
package koma.internal.default.generated.ndarray
import koma.ndarray.*
import koma.internal.getRng
import koma.internal.syncNotNative
class DefaultFloatNDArrayFactory: NumericalNDArrayFactory<Float> {
override fun createGeneric(lengths: IntArray, filler: (IntArray)->Float) = DefaultFloatNDArray(*lengths, init=filler)
override fun zeros(vararg lengths: Int) = DefaultFloatNDArray(*lengths) { 0.0f }
override fun ones(vararg lengths: Int) = DefaultFloatNDArray(*lengths) { 1.0f }
override fun rand(vararg lengths: Int): NDArray<Float> {
val rng = getRng()
return syncNotNative(rng) {
DefaultFloatNDArray(*lengths) {
rng.nextDoubleUnsafe().toFloat()
}
}
}
override fun randn(vararg lengths: Int): NDArray<Float> {
val rng = getRng()
return syncNotNative(rng) {
DefaultFloatNDArray(*lengths) {
rng.nextGaussianUnsafe().toFloat()
}
}
}
}
| 0 | Kotlin | 0 | 0 | 765dfb206cada4b682a94e140a40ba6c6e95667b | 1,118 | koma | Apache License 2.0 |
odyssey-compose/src/commonMain/kotlin/ru/alexgladkov/odyssey/compose/navigation/RootComposeBuilder.kt | AlexGladkov | 409,687,153 | false | {"Kotlin": 124395} | package ru.alexgladkov.odyssey.compose.navigation
import androidx.compose.ui.graphics.Color
import ru.alexgladkov.odyssey.compose.AllowedDestination
import ru.alexgladkov.odyssey.compose.RootController
import ru.alexgladkov.odyssey.compose.RenderWithParams
import ru.alexgladkov.odyssey.compose.ScreenType
import ru.alexgladkov.odyssey.compose.helpers.FlowBuilderModel
import ru.alexgladkov.odyssey.compose.navigation.bottom_bar_navigation.MultiStackBuilderModel
import ru.alexgladkov.odyssey.compose.navigation.bottom_bar_navigation.TabsNavModel
import ru.alexgladkov.odyssey.core.configuration.RootConfiguration
import ru.alexgladkov.odyssey.core.configuration.RootControllerType
/**
* Base builder, declarative helper for navigation graph builder
* @see RootController
*/
class RootComposeBuilder {
private val _screens: MutableList<AllowedDestination> = mutableListOf()
private val _screenMap: HashMap<String, RenderWithParams<Any?>> = hashMapOf()
fun addScreen(
key: String,
screenMap: Map<String, RenderWithParams<Any?>>,
) {
_screens.add(AllowedDestination(key = key, screenType = ScreenType.Simple))
_screenMap.putAll(screenMap)
}
fun addFlow(
key: String,
flowBuilderModel: FlowBuilderModel
) {
_screens.add(
AllowedDestination(
key = key,
screenType = ScreenType.Flow(flowBuilderModel = flowBuilderModel)
)
)
}
fun addMultiStack(
key: String,
tabsNavModel: TabsNavModel<*>,
multiStackBuilderModel: MultiStackBuilderModel
) {
_screens.add(
AllowedDestination(
key = key,
screenType = ScreenType.MultiStack(multiStackBuilderModel, tabsNavModel)
)
)
}
fun build(): RootController = RootController(RootControllerType.Root)
.apply {
updateScreenMap(_screenMap)
setNavigationGraph(_screens)
}
} | 21 | Kotlin | 22 | 256 | 5c5d33d4f0cc47919d3eafb226d8bec3aa777eb0 | 2,011 | Odyssey | MIT License |
aws-lambda-kotlin-events/src/main/kotlin/dev/jtkt/services/lambda/runtime/events/apigw/v2/ApiGatewayV2Event.kt | jtaub | 735,085,227 | false | {"Kotlin": 76981} | package dev.jtkt.services.lambda.runtime.events.apigw.v2
import dev.jtkt.services.lambda.runtime.events.apigw.HttpMethod
import kotlinx.datetime.Instant
/**
* Contains fields common to both the Http and Websocket API gateway events.
*/
interface ApiGatewayV2Event {
val body: String
val headers: Map<String, String>
val httpMethod: HttpMethod
val isBase64Encoded: Boolean
val requestContext: RequestContext
val stageVariables: Map<String, String>
}
interface RequestContext {
val accountId: String
val apiId: String
val domainName: String
val requestId: String
val routeKey: String
val stage: String
val timeEpoch: Long
val time: Instant
get() = Instant.fromEpochMilliseconds(timeEpoch)
}
| 0 | Kotlin | 0 | 0 | 94c3f1523fa0786802c43aad23901db2ec9ae218 | 758 | aws-lambda-kotlin-libs | Apache License 2.0 |
libs/pandautils/src/main/java/com/instructure/pandautils/features/shareextension/progress/ShareExtensionProgressViewData.kt | instructure | 179,290,947 | false | null | package com.instructure.pandautils.features.shareextension.progress
import androidx.annotation.DrawableRes
import androidx.databinding.BaseObservable
import androidx.databinding.Bindable
import com.instructure.pandautils.features.file.upload.FileUploadType
import com.instructure.pandautils.features.shareextension.progress.itemviewmodels.FileProgressItemViewModel
data class ShareExtensionProgressViewData(
val items: List<FileProgressItemViewModel>,
val dialogTitle: String,
val subtitle: String?,
val maxSize: String,
@get:Bindable var progressInt: Int,
@get:Bindable var percentage: String,
@get:Bindable var currentSize: String
) : BaseObservable()
data class FileProgressViewData(
val name: String,
val size: String,
@DrawableRes val icon: Int,
@get:Bindable var uploaded: Boolean
) : BaseObservable()
sealed class ShareExtensionProgressAction {
object Close : ShareExtensionProgressAction()
data class CancelUpload(val title: String, val message: String) : ShareExtensionProgressAction()
data class ShowSuccessDialog(val fileUploadType: FileUploadType) : ShareExtensionProgressAction()
data class ShowErrorDialog(val fileUploadType: FileUploadType) : ShareExtensionProgressAction()
} | 2 | Kotlin | 85 | 99 | 1bac9958504306c03960bdce7fbb87cc63bc6845 | 1,254 | canvas-android | Apache License 2.0 |
app/src/main/java/xyz/yhsj/elauncher/MainActivity.kt | yhsj0919 | 253,731,981 | false | null | package xyz.yhsj.elauncher
import android.Manifest
import android.annotation.SuppressLint
import android.app.Activity
import android.app.NotificationManager
import android.app.WallpaperManager
import android.content.BroadcastReceiver
import android.content.ContentValues.TAG
import android.content.Context
import android.content.Intent
import android.content.IntentFilter
import android.graphics.Bitmap
import android.graphics.Color
import android.graphics.PixelFormat
import android.graphics.drawable.BitmapDrawable
import android.hardware.display.DisplayManager
import android.media.Image
import android.media.ImageReader
import android.media.projection.MediaProjection
import android.media.projection.MediaProjectionManager
import android.net.wifi.WifiManager
import android.os.Build
import android.os.Bundle
import android.os.Handler
import android.provider.Settings
import android.util.DisplayMetrics
import android.util.Log
import android.view.GestureDetector
import android.view.KeyEvent
import android.view.MotionEvent
import android.view.View
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.recyclerview.widget.GridLayoutManager
import kotlinx.android.synthetic.main.activity_main.*
import org.greenrobot.eventbus.EventBus
import xyz.yhsj.elauncher.adapter.AppListAdapter
import xyz.yhsj.elauncher.bean.AppInfo
import xyz.yhsj.elauncher.event.MessageEvent
import xyz.yhsj.elauncher.permission.RxPermission
import xyz.yhsj.elauncher.service.HoverBallService
import xyz.yhsj.elauncher.setting.EmptyStartActivity
import xyz.yhsj.elauncher.setting.SettingActivity
import xyz.yhsj.elauncher.utils.*
import xyz.yhsj.elauncher.widget.AppDialog
import java.nio.ByteBuffer
import java.util.*
import kotlin.concurrent.thread
class MainActivity : AppCompatActivity() {
lateinit var appListAdapter: AppListAdapter
lateinit var appChangeReceiver: AppChangeReceiver
lateinit var notificationReceiver: NotificationReceiver
lateinit var wifiManager: WifiManager
lateinit var mNM: NotificationManager
lateinit var layoutManager: GridLayoutManager
lateinit var listGesture: GestureDetector
lateinit var bGgesture: GestureDetector
val REQUEST_MEDIA_PROJECTION = 4656
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
//获取wifi管理服务
wifiManager = applicationContext.getSystemService(Context.WIFI_SERVICE) as WifiManager
mNM = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
Notifications.createNotification(this, mNM)
}
//应用自启动
if (SpUtil.getBoolean(this, ActionKey.AUTO_RUN, false)) {
val packageName = SpUtil.getString(this, ActionKey.AUTO_RUN_PACKAGE, "")!!
val intent = Intent(this, EmptyStartActivity::class.java)
intent.putExtra("packageName", packageName)
startActivity(intent)
}
//开启悬浮球
if ((Build.VERSION.SDK_INT < Build.VERSION_CODES.M || Settings.canDrawOverlays(this))
&& SpUtil.getBoolean(this, ActionKey.HOVER_BALL, false)
) {
startService(Intent(this, HoverBallService::class.java))
}
//监听app安装，卸载，更新
val appFilter = IntentFilter()
appFilter.addAction(Intent.ACTION_PACKAGE_ADDED)
appFilter.addAction(Intent.ACTION_PACKAGE_REMOVED)
appFilter.addAction(Intent.ACTION_PACKAGE_REPLACED)
appFilter.addAction(ActionKey.ACTION_PACKAGE_HIDE)
appFilter.addAction(ActionKey.ACTION_APP_LIST_CHANGE)
appFilter.addDataScheme("package")
appChangeReceiver = AppChangeReceiver()
registerReceiver(appChangeReceiver, appFilter)
//监听通知事件
val notificationFilter = IntentFilter()
notificationFilter.addAction(ActionKey.ACTION_HOVER_BALL)
//wifi开关
notificationFilter.addAction(ActionKey.ACTION_WIFI_STATUS)
notificationFilter.addAction(ActionKey.ACTION_SYSTEM_SCREENSHOT)
notificationFilter.addAction(Intent.ACTION_WALLPAPER_CHANGED)
notificationReceiver = NotificationReceiver()
registerReceiver(notificationReceiver, notificationFilter)
//初始化应用列表
appListAdapter = AppListAdapter(appList)
layoutManager = GridLayoutManager(this, SpUtil.getInt(this, ActionKey.APP_LIST_COLUMN, 5))
layoutManager.reverseLayout = SpUtil.getBoolean(this, ActionKey.APP_LIST_ARRANGE, true)
appList.layoutManager = layoutManager
appList.adapter = appListAdapter
appListAdapter.setOnItemClickListener { _, _, position ->
val appInfo = appListAdapter.data[position]
if (appInfo.isApp) {
val intent = Intent(this, EmptyStartActivity::class.java)
intent.putExtra("packageName", appInfo.packageName)
startActivity(intent)
} else {
when (appInfo.packageName) {
"setting" -> {
startActivity(Intent(this, SettingActivity::class.java))
}
"clear" -> {
sendBroadcast(Intent("com.mogu.clear_mem"))
}
"wifi" -> {
sendBroadcast(Intent(ActionKey.ACTION_WIFI_STATUS))
}
}
}
}
appListAdapter.setOnItemLongClickListener { _, _, position ->
val appInfo = appListAdapter.data[position]
if (appInfo.isApp) {
AppDialog(
this,
appName = appInfo.name,
appIcon = appInfo.icon!!,
appPackage = appInfo.packageName,
appVersion = appInfo.version,
appTime = appInfo.updateTime
).show()
}
return@setOnItemLongClickListener true
}
//手势处理
listGesture = GestureDetector(this, object :
GestureDetector.SimpleOnGestureListener() {
override fun onDoubleTap(e: MotionEvent?): Boolean {
appList.visibility = View.GONE
return true
}
})
bGgesture = GestureDetector(this, object :
GestureDetector.SimpleOnGestureListener() {
override fun onDoubleTap(e: MotionEvent?): Boolean {
appList.visibility = View.VISIBLE
return true
}
override fun onScroll(
e1: MotionEvent,
e2: MotionEvent,
distanceX: Float,
distanceY: Float
): Boolean {
if (e1.y - e2.y > Math.abs(e1.x - e2.x) && e1.y - e2.y > 100) {
//上
appList.visibility = View.VISIBLE
return true
}
return true
}
})
appList.setOnTouchListener { view, motionEvent ->
return@setOnTouchListener listGesture.onTouchEvent(motionEvent)
}
mainBg.setOnTouchListener { view, motionEvent ->
return@setOnTouchListener bGgesture.onTouchEvent(motionEvent)
}
refreshApp()
getSysWallpaper()
var mediaProjectionManager =
getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
startActivityForResult(
mediaProjectionManager.createScreenCaptureIntent(),
REQUEST_MEDIA_PROJECTION
)
}
/**
* 刷新应用列表
*/
fun refreshApp() {
layoutManager.spanCount = SpUtil.getInt(this, ActionKey.APP_LIST_COLUMN, 5)
//设置蒙版透明度
appList.setBackgroundColor(
Color.argb(
SpUtil.getInt(this, ActionKey.APP_LIST_ALPHA, 200),
255,
255,
255
)
)
val arrange = SpUtil.getBoolean(this, ActionKey.APP_LIST_ARRANGE, true)
layoutManager.reverseLayout = arrange
thread {
val appInfos = getAllApp(this)
appInfos.add(
AppInfo(
name = getString(R.string.桌面设置),
packageName = "setting",
isApp = false,
updateTime = if (arrange) 0 else Date().time
)
)
if (SpUtil.getBoolean(this, ActionKey.APP_LIST_CLEAR_SHOW, true)) {
appInfos.add(
AppInfo(
name = getString(R.string.清理后台_Boost), packageName = "clear", isApp = false,
updateTime = if (arrange) 0 else Date().time
)
)
}
if (SpUtil.getBoolean(this, ActionKey.APP_LIST_WIFI_SHOW, true)) {
appInfos.add(
AppInfo(
name = getString(R.string.wifi), packageName = "wifi", isApp = false,
updateTime = if (arrange) 0 else Date().time
)
)
}
// 如果需要更新UI 回到主线程中进行处理
val apps = appInfos.filter {
!SpUtil.getBoolean(this, it.packageName, false)
}
.filter { it.packageName != this.packageName }
.sortedBy { it.updateTime }
runOnUiThread {
appListAdapter.data = apps
}
}
}
/**
* 销毁广播监听
*/
override fun onDestroy() {
super.onDestroy()
unregisterReceiver(appChangeReceiver)
unregisterReceiver(notificationReceiver)
}
/**
* 拦截返回键、Home键
*/
override fun onKeyDown(keyCode: Int, event: KeyEvent?): Boolean {
if (keyCode == KeyEvent.KEYCODE_BACK) {
return false
}
return if (keyCode == KeyEvent.KEYCODE_HOME) {
false
} else super.onKeyDown(keyCode, event)
}
/**
* 内部类，监听APP变化
*/
inner class AppChangeReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
/**
* 获取（安装/替换/卸载）应用的 信息
*/
val packages = intent.dataString?.replace("package:", "")
val action = intent.action
when (action) {
Intent.ACTION_PACKAGE_ADDED -> {
Log.e(TAG, packages + "应用程序安装了")
refreshApp()
}
Intent.ACTION_PACKAGE_REMOVED -> {
Log.e(TAG, packages + "应用程序卸载了")
SpUtil.remove(context, packages + "")
refreshApp()
}
Intent.ACTION_PACKAGE_REPLACED -> {
Log.e(TAG, packages + "应用程序覆盖了")
SpUtil.remove(context, packages + "")
refreshApp()
}
ActionKey.ACTION_PACKAGE_HIDE -> {
Log.e(TAG, packages + "应用程序隐藏")
refreshApp()
}
ActionKey.ACTION_APP_LIST_CHANGE -> {
Log.e(TAG, packages + "列表发生变化")
refreshApp()
}
}
}
}
/**
* 内部类，监听通知变化
*/
inner class NotificationReceiver : BroadcastReceiver() {
override fun onReceive(context: Context, intent: Intent) {
val action = intent.action
when (action) {
//开关悬浮球
ActionKey.ACTION_HOVER_BALL -> {
context.sendBroadcast(Intent("com.mogu.back_key"))
EventBus.getDefault().post(MessageEvent(ActionKey.ACTION_HOVER_BALL))
}
ActionKey.ACTION_WIFI_STATUS -> {
//获取wifi开关状态
val status = wifiManager.wifiState
if (status == WifiManager.WIFI_STATE_ENABLED) {
//wifi打开状态则关闭
wifiManager.isWifiEnabled = false;
Toast.makeText(this@MainActivity, getString(R.string.wifi已关闭), Toast.LENGTH_SHORT).show()
} else {
//关闭状态则打开
wifiManager.isWifiEnabled = true;
Toast.makeText(this@MainActivity, getString(R.string.wifi已打开), Toast.LENGTH_SHORT).show()
}
}
Intent.ACTION_WALLPAPER_CHANGED -> {
Log.e(TAG, "壁纸修改")
getSysWallpaper()
}
ActionKey.ACTION_SYSTEM_SCREENSHOT -> {
Log.e(TAG, "开启截图权限")
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
var mediaProjectionManager =
getSystemService(Context.MEDIA_PROJECTION_SERVICE) as MediaProjectionManager
startActivityForResult(
mediaProjectionManager.createScreenCaptureIntent(),
REQUEST_MEDIA_PROJECTION
)
}
}
}
}
}
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
when (requestCode) {
REQUEST_MEDIA_PROJECTION -> {
if (resultCode == Activity.RESULT_OK && data != null) {
HoverBallService.resultData = data
} else {
Toast.makeText(this, "截图功能失效，使用时请开启相关服务", Toast.LENGTH_SHORT).show()
}
}
}
}
@SuppressLint("CheckResult")
fun getSysWallpaper() {
RxPermission(this)
.request(
Manifest.permission.WRITE_EXTERNAL_STORAGE,
Manifest.permission.READ_EXTERNAL_STORAGE
)
.subscribe({
// 获取壁纸管理器
val wallpaperManager = WallpaperManager.getInstance(this)
// 获取当前壁纸
val wallpaperDrawable = wallpaperManager.drawable
// 将Drawable,转成Bitmap
val bm = (wallpaperDrawable as BitmapDrawable).bitmap
// 设置 背景
mainBg.background = (BitmapDrawable(bm))
}, {
Toast.makeText(this, "壁纸功能需要读写权限才能实现", Toast.LENGTH_LONG).show()
})
}
} | 1 | null | 8 | 21 | ce26222228f7156228e0c3762caca2bcfa6bdf1e | 14,639 | ELauncher | Apache License 2.0 |
data/src/main/java/com/moraware/data/models/RetrieveOrdersForMealResponse.kt | lpalac4 | 520,184,920 | false | null | package com.moraware.data.models
import com.moraware.data.base.BaseResponse
import com.moraware.data.entities.OrderEntity
class RetrieveOrdersForMealResponse(val orders: MutableList<OrderEntity>) : BaseResponse() {
} | 0 | Kotlin | 0 | 0 | 39812a9a320bcebed883b5f6f804dfd43458f816 | 218 | mango | MIT License |
app/src/main/java/ru/ilyasekunov/officeapp/data/datasource/local/mock/MockUserDataSource.kt | IlyaSekunov | 744,587,168 | false | {"Kotlin": 671010} | package ru.ilyasekunov.officeapp.data.datasource.local.mock
import kotlinx.coroutines.delay
import ru.ilyasekunov.officeapp.data.datasource.UserDataSource
import ru.ilyasekunov.officeapp.data.dto.UserDto
class MockUserDataSource : UserDataSource {
override suspend fun saveChanges(userDto: UserDto): Result<Unit> {
delay(3000L)
User = User?.copy(
name = userDto.name,
surname = userDto.surname,
job = userDto.job,
photo = userDto.photo ?: "",
office = Offices.find { it.id == userDto.officeId }!!
)
return Result.success(Unit)
}
} | 0 | Kotlin | 0 | 2 | 9cb85aeef71463a480ba1a3dff4a32af929263eb | 632 | office-app | Apache License 2.0 |
app/src/main/java/com/example/buynow/utils/CardType.kt | JahidHasanCO | 372,423,290 | false | null | package com.example.amantoliv2.Utils
import java.util.regex.Pattern
enum class CardType {
UNKNOWN,
VISA("^4[0-9]{12}(?:[0-9]{3}){0,2}$"),
MASTERCARD("^(?:5[1-5]|2(?!2([01]|20)|7(2[1-9]|3))[2-7])\\d{14}$"),
AMERICAN_EXPRESS(
"^3[47][0-9]{13}$"
),
DINERS_CLUB("^3(?:0[0-5]\\d|095|6\\d{0,2}|[89]\\d{2})\\d{12,15}$"),
DISCOVER("^6(?:011|[45][0-9]{2})[0-9]{12}$"),
JCB(
"^(?:2131|1800|35\\d{3})\\d{11}$"
),
CHINA_UNION_PAY("^62[0-9]{14,17}$");
private var pattern: Pattern?
constructor() {
pattern = null
}
constructor(pattern: String) {
this.pattern = Pattern.compile(pattern)
}
companion object {
fun detect(cardNumber: String?): CardType {
for (cardType in values()) {
if (null == cardType.pattern) continue
if (cardType.pattern!!.matcher(cardNumber).matches()) return cardType
}
return UNKNOWN
}
}
} | 1 | null | 23 | 79 | d29ab268a5e42f0bb0d8aecdf08205e1ad95b76f | 990 | BuyNow.-The-E-commerce-App | MIT License |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.